Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

17.9 KB
Raw Blame
//! Byte-stream protocol regressions: exercise the same framing used by Zed.
use codex_cloud_agents::domain::acp_session::{SessionService, SessionStore, StoredSession};
use codex_cloud_agents::domain::cloud::*;
use codex_cloud_agents::domain::journal::{JournalEntry, JournalInput};
use codex_cloud_agents::domain::*;
use codex_cloud_agents::inbound::acp::serve;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::sync::{
    Arc, Mutex,
    atomic::{AtomicBool, AtomicUsize, Ordering},
};
use tokio::io::{AsyncBufReadExt as _, AsyncWriteExt as _, BufReader, DuplexStream};

type Result<T> = std::result::Result<T, rootcause::Report>;
#[derive(Clone, Default)]
struct Journal(
    Arc<Mutex<HashMap<String, StoredSession>>>,
    Arc<Mutex<HashMap<String, Vec<JournalEntry>>>>,
);
impl SessionStore for Journal {
    async fn load(&self, id: &str) -> Result<Option<StoredSession>> {
        Ok(self.0.lock().unwrap().get(id).cloned())
    }
    async fn save(&self, id: &str, state: &StoredSession) -> Result<()> {
        self.0.lock().unwrap().insert(id.into(), state.clone());
        Ok(())
    }
    async fn read(&self, id: &str) -> std::result::Result<Vec<JournalEntry>, rootcause::Report> {
        Ok(self.1.lock().unwrap().get(id).cloned().unwrap_or_default())
    }
    async fn append(
        &self,
        id: &str,
        expected: i64,
        turn: Option<&TurnId>,
        input: &JournalInput,
    ) -> std::result::Result<JournalEntry, rootcause::Report> {
        let mut journals = self.1.lock().unwrap();
        let entries = journals.entry(id.to_owned()).or_default();
        if entries.len() as i64 != expected {
            return Err(rootcause::report!("stale sequence"));
        }
        let entry = JournalEntry {
            sequence: expected + 1,
            turn: turn.cloned(),
            input: input.clone(),
        };
        entries.push(entry.clone());
        Ok(entry)
    }
    async fn validate(&self) -> Result<()> {
        Ok(())
    }
}
struct Auth;
impl CredentialStore for Auth {
    fn load(&self) -> Result<Option<Credentials>> {
        Ok(Some(Credentials {
            version: 1,
            access_token: Secret::new("test-access".into())?,
            refresh_token: Secret::new("test-refresh".into())?,
            expires_at: u64::MAX,
            account_id: "test-account".into(),
        }))
    }
    fn save(&self, _: &Credentials) -> Result<()> {
        Ok(())
    }
    fn clear(&self) -> Result<()> {
        Ok(())
    }
}
#[derive(Default)]
struct Calls {
    creates: AtomicUsize,
    follows: AtomicUsize,
    cancels: AtomicUsize,
    turn: AtomicUsize,
    done: AtomicBool,
    hold: AtomicBool,
    input_request: AtomicBool,
    recorded: AtomicBool,
    cancelled: AtomicBool,
}
#[derive(Clone, Default)]
struct Provider(Arc<Calls>);
impl Provider {
    fn receipt(&self, prompt: &str) -> Result<CreatedTask> {
        let turn = self.0.turn.fetch_add(1, Ordering::SeqCst) + 1;
        self.0.done.store(false, Ordering::SeqCst);
        self.0
            .recorded
            .store(prompt.contains("recorded"), Ordering::SeqCst);
        self.0
            .input_request
            .store(prompt.contains("elicitation"), Ordering::SeqCst);
        self.0.cancelled.store(false, Ordering::SeqCst);
        self.0.hold.store(prompt.contains("hold"), Ordering::SeqCst);
        Ok(CreatedTask {
            task_id: CloudId::new("task-test".into())?,
            assistant_turn_id: Some(TurnId::new(format!("turn-{turn}"))?),
            url: "https://chatgpt.com/codex/tasks/task-test".into(),
        })
    }
    fn snapshot(&self) -> Result<TaskSnapshot> {
        let status = if self.0.cancelled.load(Ordering::SeqCst) {
            "cancelled"
        } else if self.0.done.load(Ordering::SeqCst) {
            "completed"
        } else {
            "in_progress"
        };
        Ok(TaskSnapshot {
            pull_requests: vec![],
            native: None,
            task_id: CloudId::new("task-test".into())?,
            title: Some("Test".into()),
            assistant_status: Some(status.into()),
            turns: vec![TurnSnapshot {
                source: "current_assistant_turn".into(),
                id: Some(format!("turn-{}", self.0.turn.load(Ordering::SeqCst))),
                messages: vec![],
                output_types: vec![],
                has_diff: false,
            }],
        })
    }
}
impl OAuth for Provider {
    async fn begin(&self) -> Result<DeviceLogin> {
        Err(rootcause::report!("login not expected"))
    }
    async fn poll(&self, _: &DeviceLogin) -> Result<LoginPoll> {
        Err(rootcause::report!("poll not expected"))
    }
    async fn refresh(&self, _: &Credentials) -> Result<Credentials> {
        Err(rootcause::report!("refresh not expected"))
    }
    async fn environments(&self, _: &Credentials) -> Result<Vec<Environment>> {
        Ok(vec![Environment {
            id: "env-test".into(),
            label: None,
            repositories: vec![],
        }])
    }
}
impl CloudTasks for Provider {
    async fn create(&self, _: &Credentials, request: &Launch) -> Result<CreatedTask> {
        self.0.creates.fetch_add(1, Ordering::SeqCst);
        self.receipt(&request.prompt)
    }
    async fn snapshot(&self, _: &Credentials, _: &CloudId) -> Result<TaskSnapshot> {
        self.snapshot()
    }
}
impl CloudConversation for Provider {
    async fn follow_up(
        &self,
        _: &Credentials,
        _: &CloudId,
        _: &TurnId,
        prompt: &str,
    ) -> Result<CreatedTask> {
        self.0.follows.fetch_add(1, Ordering::SeqCst);
        self.receipt(prompt)
    }
    async fn cancel(&self, _: &Credentials, _: &CloudId) -> Result<()> {
        self.0.cancels.fetch_add(1, Ordering::SeqCst);
        self.0.cancelled.store(true, Ordering::SeqCst);
        Ok(())
    }
    async fn turn(&self, _: &Credentials, _: &CloudId, _: &TurnId) -> Result<TaskSnapshot> {
        self.snapshot()
    }
    async fn stream(
        &self,
        _: &Credentials,
        _: &CloudId,
        turn: &TurnId,
    ) -> Result<CloudEventStream> {
        use futures::StreamExt as _;
        let id = turn.as_str();
        if self.0.recorded.load(Ordering::SeqCst) {
            let events: Vec<CloudEvent> =
                serde_json::from_str(include_str!("fixtures/recorded_cloud_turn.json")).unwrap();
            let calls = self.0.clone();
            return Ok(Box::pin(
                futures::stream::iter(
                    events
                        .into_iter()
                        .map(|event| Ok(NativeRecord::from_event(event.clone()))),
                )
                .chain(futures::stream::once(async move {
                    calls.done.store(true, Ordering::SeqCst);
                    Ok(NativeRecord::from_event(CloudEvent {
                        id: "fixture-end".into(),
                        method: "turn/completed".into(),
                        params: json!({}),
                    }))
                })),
            ));
        }
        if self.0.input_request.load(Ordering::SeqCst) {
            return Ok(Box::pin(futures::stream::iter(vec![Ok(
                NativeRecord::from_event(CloudEvent {
                    id: format!("{id}-input"),
                    method: "item/tool/requestUserInput".into(),
                    params: json!({"requestId":"question-1","questions":[{"id":"choice","question":"Choose a branch"}]}),
                }),
            )])));
        }
        let event = CloudEvent {
            id: format!("{id}-delta"),
            method: "item/agentMessage/delta".into(),
            params: json!({"threadId":"task-test","turnId":id,"itemId":format!("{id}-message"),"delta":"Hello 🌍"}),
        };
        let complete = CloudEvent {
            id: format!("{id}-complete"),
            method: "item/completed".into(),
            params: json!({"threadId":"task-test","turnId":id,"item":{"id":format!("{id}-message"),"type":"agentMessage","text":"Hello 🌍"}}),
        };
        if self.0.hold.load(Ordering::SeqCst) {
            let activity = CloudEvent {
                id: format!("{id}-tool"),
                method: "item/started".into(),
                params: json!({"item":{"id":"running-tool","type":"commandExecution","command":"sleep 60"}}),
            };
            return Ok(Box::pin(
                futures::stream::iter(vec![Ok(NativeRecord::from_event(activity))])
                    .chain(futures::stream::pending()),
            ));
        }
        let calls = self.0.clone();
        Ok(Box::pin(
            futures::stream::iter(vec![
                Ok(NativeRecord::from_event(event.clone())),
                Ok(NativeRecord::from_event(event.clone())),
                Ok(NativeRecord::from_event(complete)),
            ])
            .chain(futures::stream::once(async move {
                calls.done.store(true, Ordering::SeqCst);
                Ok(NativeRecord::from_event(CloudEvent {
                    id: format!("done-{}", calls.turn.load(Ordering::SeqCst)),
                    method: "turn/completed".into(),
                    params: json!({}),
                }))
            })),
        ))
    }
}
struct Client {
    read: BufReader<tokio::io::ReadHalf<DuplexStream>>,
    write: tokio::io::WriteHalf<DuplexStream>,
    server: tokio::task::JoinHandle<()>,
}
impl Client {
    async fn send(&mut self, frame: Value) {
        self.write
            .write_all(format!("{frame}\n").as_bytes())
            .await
            .unwrap();
        self.write.flush().await.unwrap();
    }
    async fn next(&mut self) -> Value {
        let mut line = String::new();
        let count = tokio::time::timeout(
            std::time::Duration::from_secs(15),
            self.read.read_line(&mut line),
        )
        .await
        .expect("ACP response timed out")
        .unwrap();
        assert_ne!(count, 0, "ACP unexpectedly closed");
        serde_json::from_str(&line).expect("stdout contains only JSON protocol frames")
    }
    async fn call(&mut self, id: i64, method: &str, params: Value) -> Vec<Value> {
        self.send(json!({"jsonrpc":"2.0","id":id,"method":method,"params":params}))
            .await;
        let mut frames = vec![];
        loop {
            let frame = self.next().await;
            let done = frame["id"] == id;
            frames.push(frame);
            if done {
                return frames;
            }
        }
    }
}
impl Drop for Client {
    fn drop(&mut self) {
        self.server.abort();
    }
}
fn harness(provider: Provider, journal: Journal) -> Client {
    let service = Arc::new(SessionService::new(
        Arc::new(Probe::new(provider, Auth)),
        journal,
        Some(codex_cloud_agents::domain::runtime::CloudTarget {
            environment: CloudId::new("env-test".into()).unwrap(),
            branch: "main".into(),
            repository_url: None,
        }),
    ));
    let (client, agent) = tokio::io::duplex(128 * 1024);
    let (read, write) = tokio::io::split(client);
    let (agent_read, agent_write) = tokio::io::split(agent);
    let server = tokio::spawn(async move {
        let _ = serve(service, agent_read, agent_write, None).await;
    });
    Client {
        read: BufReader::new(read),
        write,
        server,
    }
}
async fn initialize(client: &mut Client) -> Value {
    client.call(1,"initialize",json!({"protocolVersion":1,"clientCapabilities":{},"clientInfo":{"name":"stdio-test","version":"1"}})).await.pop().unwrap()
}
fn normalize(value: &Value, session: &str) -> Value {
    match value {
        Value::String(text) => Value::String(text.replace(session, "SESSION")),
        Value::Array(items) => Value::Array(items.iter().map(|v| normalize(v, session)).collect()),
        Value::Object(items) => Value::Object(
            items
                .iter()
                .map(|(k, v)| (k.clone(), normalize(v, session)))
                .collect(),
        ),
        _ => value.clone(),
    }
}
#[tokio::test]
async fn stdio_messages_followups_and_stop_snapshot() {
    let provider = Provider::default();
    let mut client = harness(provider.clone(), Journal::default());
    let init = initialize(&mut client).await;
    let new = client
        .call(
            2,
            "session/new",
            json!({"cwd":"/unrelated/local/repo","mcpServers":[]}),
        )
        .await;
    let session = new.last().unwrap()["result"]["sessionId"]
        .as_str()
        .unwrap()
        .to_owned();
    let first = client
        .call(
            3,
            "session/prompt",
            json!({"sessionId":session,"prompt":[{"type":"text","text":"hello"}]}),
        )
        .await;
    let second = client
        .call(
            4,
            "session/prompt",
            json!({"sessionId":session,"prompt":[{"type":"text","text":"again"}]}),
        )
        .await;
    client.send(json!({"jsonrpc":"2.0","id":5,"method":"session/prompt","params":{"sessionId":session,"prompt":[{"type":"text","text":"hold"}]}})).await;
    let mut stopped = vec![client.next().await];
    client
        .send(json!({"jsonrpc":"2.0","method":"session/cancel","params":{"sessionId":session}}))
        .await;
    loop {
        let frame = client.next().await;
        let done = frame["id"] == 5;
        stopped.push(frame);
        if done {
            break;
        }
    }
    assert_eq!(provider.0.creates.load(Ordering::SeqCst), 1);
    assert_eq!(provider.0.follows.load(Ordering::SeqCst), 2);
    assert!(provider.0.cancels.load(Ordering::SeqCst) >= 1);
    assert_eq!(first.last().unwrap()["result"]["stopReason"], "end_turn");
    assert_eq!(second.last().unwrap()["result"]["stopReason"], "end_turn");
    assert_eq!(stopped.last().unwrap()["result"]["stopReason"], "cancelled");
    insta::assert_json_snapshot!(
        "stdio_messages_followups_stop",
        normalize(
            &json!({"initialize":init,"new":new,"first":first,"followup":second,"stop":stopped}),
            &session
        )
    );
}
#[tokio::test]
async fn stdio_unsupported_inputs_do_not_launch_cloud_work() {
    let provider = Provider::default();
    let mut client = harness(provider.clone(), Journal::default());
    initialize(&mut client).await;
    let new = client
        .call(2, "session/new", json!({"cwd":"/tmp","mcpServers":[]}))
        .await;
    let session = new.last().unwrap()["result"]["sessionId"]
        .as_str()
        .unwrap()
        .to_owned();
    let image = client.call(3,"session/prompt",json!({"sessionId":session,"prompt":[{"type":"image","data":"AA==","mimeType":"image/png"}]})).await;
    let empty = client
        .call(
            4,
            "session/prompt",
            json!({"sessionId":session,"prompt":[]}),
        )
        .await;
    let unknown = client
        .call(
            5,
            "session/set_mode",
            json!({"sessionId":session,"modeId":"bypass"}),
        )
        .await;
    assert!(image.last().unwrap().get("error").is_some());
    assert!(empty.last().unwrap().get("error").is_some());
    assert!(unknown.last().unwrap().get("error").is_some());
    assert_eq!(provider.0.creates.load(Ordering::SeqCst), 0);
    insta::assert_json_snapshot!(
        "stdio_unsupported_inputs",
        normalize(
            &json!({"image":image,"empty":empty,"unsupported_mode":unknown}),
            &session
        )
    );
}

#[tokio::test]
async fn stdio_unsupported_elicitation_requests_remote_stop_without_fake_approval() {
    let provider = Provider::default();
    let mut client = harness(provider.clone(), Journal::default());
    initialize(&mut client).await;
    let new = client
        .call(2, "session/new", json!({"cwd":"/tmp","mcpServers":[]}))
        .await;
    let session = new.last().unwrap()["result"]["sessionId"]
        .as_str()
        .unwrap()
        .to_owned();
    let frames = client
        .call(
            3,
            "session/prompt",
            json!({"sessionId":session,"prompt":[{"type":"text","text":"elicitation"}]}),
        )
        .await;
    assert!(frames.last().unwrap().get("error").is_some());
    assert_eq!(provider.0.cancels.load(Ordering::SeqCst), 1);
    assert!(
        !frames
            .iter()
            .any(|frame| frame["method"] == "session/request_permission")
    );
    // Keep source-location diagnostics out of fixture identity; the actionable sentence matters.
    let mut frames = normalize(&json!(frames), &session);
    for frame in frames.as_array_mut().unwrap() {
        if let Some(message) = frame.pointer_mut("/error/message") {
            let message_text = message.as_str().unwrap();
            let sentence = message_text
                .lines()
                .find(|line| line.contains("unsupported"))
                .unwrap_or(message_text);
            *message = json!(sentence.trim().trim_start_matches('●').trim());
        }
    }
    insta::assert_json_snapshot!("stdio_unsupported_elicitation", frames);
}

#[tokio::test]
async fn stdio_recorded_cloud_turn_snapshot() {
    let provider = Provider::default();
    let mut client = harness(provider.clone(), Journal::default());
    initialize(&mut client).await;
    let new = client
        .call(2, "session/new", json!({"cwd":"/tmp","mcpServers":[]}))
        .await;
    let session = new.last().unwrap()["result"]["sessionId"]
        .as_str()
        .unwrap()
        .to_owned();
    let frames = client
        .call(
            3,
            "session/prompt",
            json!({"sessionId":session,"prompt":[{"type":"text","text":"recorded"}]}),
        )
        .await;
    assert_eq!(frames.last().unwrap()["result"]["stopReason"], "end_turn");
    assert!(frames.iter().any(|frame|frame.pointer("/params/update/sessionUpdate")==Some(&json!("tool_call"))));
    assert!(
        frames
            .iter()
            .any(|frame| frame.pointer("/params/update/sessionUpdate")
                == Some(&json!("agent_message_chunk")))
    );
    assert_eq!(provider.0.creates.load(Ordering::SeqCst), 1);
    insta::assert_json_snapshot!(
        "stdio_recorded_cloud_turn",
        normalize(&json!(frames), &session)
    );
}