@corbet-labs/ccht 0.1.0

package/source/src/native/tests.rs

@@ -0,0 +1,427 @@
+use super::*;
+use crate::acp::{ContentBlock, SelectedPermissionOutcome, SessionUpdate, StopReason};
+use crate::{Event, Prompt, SessionEvent};
+use tokio::sync::mpsc;
+use tokio::time::timeout;
+
+fn options() -> NativeOptions {
+    NativeOptions {
+        operation_timeout: Duration::from_secs(5),
+        prompt_timeout: Duration::from_secs(5),
+        permission_timeout: Duration::from_secs(2),
+        shutdown_timeout: Duration::from_secs(2),
+        ..NativeOptions::default()
+    }
+}
+
+fn command(mode: &str) -> AgentCommand {
+    AgentCommand::new("python3").args(["-u", "-c", include_str!("fixture.py"), mode])
+}
+
+fn prompt(id: &str) -> Prompt {
+    Prompt {
+        request_id: id.into(),
+        content: vec!["test".into()],
+    }
+}
+
+async fn session(
+    mode: &str,
+    options: NativeOptions,
+) -> (
+    NativeClient,
+    NativeSession,
+    SessionHandle,
+    mpsc::Receiver<SessionEvent>,
+) {
+    let client = NativeClient::connect(command(mode), options).await.unwrap();
+    let mut session = client
+        .new_session(SessionOptions::new(std::env::temp_dir()))
+        .await
+        .unwrap();
+    let handle = session.handle();
+    let events = session.take_events().unwrap();
+    (client, session, handle, events)
+}
+
+fn text(event: &SessionEvent) -> Option<&str> {
+    match &event.event {
+        Event::Update {
+            update: SessionUpdate::AgentMessageChunk(chunk),
+        } => {
+            if let ContentBlock::Text(content) = &chunk.content {
+                Some(&content.text)
+            } else {
+                None
+            }
+        }
+        _ => None,
+    }
+}
+
+#[tokio::test]
+async fn ordered_stream_and_multiple_turns_keep_one_session() {
+    let (client, _session, handle, mut events) = session("normal", options()).await;
+    for id in ["first", "second"] {
+        assert_eq!(
+            handle.prompt(prompt(id)).await.unwrap(),
+            StopReason::EndTurn
+        );
+        let first = events.recv().await.unwrap();
+        let second = events.recv().await.unwrap();
+        let completed = events.recv().await.unwrap();
+        assert_eq!(first.request_id.as_deref(), Some(id));
+        assert_eq!(text(&first), Some("hello "));
+        assert_eq!(text(&second), Some("world"));
+        assert!(matches!(
+            completed.event,
+            Event::Completed {
+                stop_reason: StopReason::EndTurn
+            }
+        ));
+    }
+    handle.close().await.unwrap();
+    assert!(events.recv().await.is_none());
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn default_permissions_deny_without_user_approval() {
+    let (client, _session, handle, mut events) = session("deny", options()).await;
+    handle.prompt(prompt("deny")).await.unwrap();
+    assert_eq!(text(&events.recv().await.unwrap()), Some("cancelled"));
+    assert!(matches!(
+        events.recv().await.unwrap().event,
+        Event::Completed { .. }
+    ));
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn permission_responses_are_validated_and_isolated_between_sessions() {
+    let mut options = options();
+    options.permissions = PermissionPolicy::Ask;
+    let (client, _first, handle, mut events) = session("ask", options).await;
+    let mut second = client
+        .new_session(SessionOptions::new(std::env::temp_dir()))
+        .await
+        .unwrap();
+    let other = second.handle();
+    let mut other_events = second.take_events().unwrap();
+    let first_prompt = tokio::spawn({
+        let handle = handle.clone();
+        async move { handle.prompt(prompt("first")).await }
+    });
+    let second_prompt = tokio::spawn({
+        let other = other.clone();
+        async move { other.prompt(prompt("second")).await }
+    });
+    let first_request = events.recv().await.unwrap();
+    let second_request = other_events.recv().await.unwrap();
+    let Event::Permission {
+        request_id,
+        request,
+    } = first_request.event
+    else {
+        panic!("permission event expected")
+    };
+    let Event::Permission {
+        request_id: second_id,
+        request: second_request,
+    } = second_request.event
+    else {
+        panic!("permission event expected")
+    };
+    assert_ne!(request.session_id, second_request.session_id);
+    assert_ne!(request_id, second_id);
+    assert_eq!(
+        other
+            .respond_permission(&request_id, PermissionDecision::Cancelled)
+            .await
+            .unwrap_err(),
+        NativeError::UnknownPermission
+    );
+    let invalid = PermissionDecision::Selected(SelectedPermissionOutcome::new("not-offered"));
+    assert_eq!(
+        handle
+            .respond_permission(&request_id, invalid)
+            .await
+            .unwrap_err(),
+        NativeError::InvalidPermissionOption
+    );
+    handle
+        .respond_permission(
+            &request_id,
+            PermissionDecision::Selected(SelectedPermissionOutcome::new("allow")),
+        )
+        .await
+        .unwrap();
+    assert_eq!(first_prompt.await.unwrap().unwrap(), StopReason::EndTurn);
+    assert!(!second_prompt.is_finished());
+    other
+        .respond_permission(&second_id, PermissionDecision::Cancelled)
+        .await
+        .unwrap();
+    assert_eq!(second_prompt.await.unwrap().unwrap(), StopReason::EndTurn);
+    assert_eq!(
+        handle
+            .respond_permission(&request_id, PermissionDecision::Cancelled)
+            .await
+            .unwrap_err(),
+        NativeError::UnknownPermission
+    );
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn active_prompt_rejects_overlap_and_cancels_cooperatively() {
+    let (client, _session, handle, mut events) = session("hang", options()).await;
+    let running = tokio::spawn({
+        let handle = handle.clone();
+        async move { handle.prompt(prompt("first")).await }
+    });
+    assert_eq!(text(&events.recv().await.unwrap()), Some("waiting"));
+    assert_eq!(
+        handle.prompt(prompt("overlap")).await.unwrap_err(),
+        NativeError::Busy
+    );
+    handle.cancel().await.unwrap();
+    assert_eq!(running.await.unwrap().unwrap(), StopReason::Cancelled);
+    assert!(matches!(
+        events.recv().await.unwrap().event,
+        Event::Completed {
+            stop_reason: StopReason::Cancelled
+        }
+    ));
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn ignored_cancellation_and_abandoned_prompts_close_the_connection() {
+    let mut limits = options();
+    limits.shutdown_timeout = Duration::from_millis(100);
+    let (client, _session, handle, mut events) = session("ignore_cancel", limits).await;
+    let running = tokio::spawn({
+        let handle = handle.clone();
+        async move { handle.prompt(prompt("first")).await }
+    });
+    events.recv().await.unwrap();
+    assert_eq!(handle.cancel().await.unwrap_err(), NativeError::Timeout);
+    assert!(running.await.unwrap().is_err());
+    assert!(
+        client
+            .new_session(SessionOptions::new(std::env::temp_dir()))
+            .await
+            .is_err()
+    );
+
+    let (client, _session, handle, mut events) = session("hang", options()).await;
+    let running = tokio::spawn({
+        let handle = handle.clone();
+        async move { handle.prompt(prompt("abandoned")).await }
+    });
+    events.recv().await.unwrap();
+    running.abort();
+    let _ = running.await;
+    assert!(
+        client
+            .new_session(SessionOptions::new(std::env::temp_dir()))
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test]
+async fn restoration_preserves_history_before_new_prompt_identity() {
+    let client = NativeClient::connect(command("normal"), options())
+        .await
+        .unwrap();
+    let mut restored = client
+        .load_session("saved-session", SessionOptions::new(std::env::temp_dir()))
+        .await
+        .unwrap();
+    assert_eq!(restored.handle().id(), "saved-session");
+    let mut events = restored.take_events().unwrap();
+    let history = events.recv().await.unwrap();
+    assert_eq!(history.request_id, None);
+    assert_eq!(text(&history), Some("restored history"));
+    restored.handle().prompt(prompt("continued")).await.unwrap();
+    assert_eq!(
+        events.recv().await.unwrap().request_id.as_deref(),
+        Some("continued")
+    );
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn auth_errors_exclude_peer_secrets_and_unknown_host_requests_fail() {
+    let client = NativeClient::connect(command("auth_required"), options())
+        .await
+        .unwrap();
+    let error = match client
+        .new_session(SessionOptions::new(std::env::temp_dir()))
+        .await
+    {
+        Ok(_) => panic!("authentication failure expected"),
+        Err(error) => error,
+    };
+    assert_eq!(error, NativeError::AuthenticationRequired);
+    assert!(!format!("{error:?} {error}").contains("SECRET"));
+
+    let (client, _session, handle, mut events) =
+        session("unsupported_host_request", options()).await;
+    handle.prompt(prompt("unsupported")).await.unwrap();
+    assert_eq!(text(&events.recv().await.unwrap()), Some("unsupported"));
+    client.close().await.unwrap();
+}
+
+#[tokio::test]
+async fn slow_consumers_fail_with_bounded_buffer_and_shutdown() {
+    let mut limits = options();
+    limits.event_capacity = 2;
+    let (client, _session, handle, _events) = session("burst", limits).await;
+    let result = timeout(Duration::from_secs(5), handle.prompt(prompt("overflow")))
+        .await
+        .unwrap();
+    assert_eq!(result.unwrap_err(), NativeError::EventBufferFull);
+    assert!(
+        client
+            .new_session(SessionOptions::new(std::env::temp_dir()))
+            .await
+            .is_err()
+    );
+}
+
+#[tokio::test]
+async fn model_selection_is_explicit_and_api_key_overrides_are_rejected() {
+    let client = NativeClient::connect(command("normal"), options())
+        .await
+        .unwrap();
+    let mut selected = SessionOptions::new(std::env::temp_dir());
+    selected.model = Some("test-model".into());
+    let mut session = client.new_session(selected.clone()).await.unwrap();
+    let _events = session.take_events().unwrap();
+    session.handle().prompt(prompt("selected")).await.unwrap();
+    selected.model = Some("missing-model".into());
+    assert!(matches!(
+        client.new_session(selected).await,
+        Err(NativeError::Unsupported(_))
+    ));
+    client.close().await.unwrap();
+    let mut keyed = command("normal");
+    keyed
+        .env
+        .insert("OPENAI_API_KEY".into(), "not-a-real-key".into());
+    assert!(matches!(
+        NativeClient::connect(keyed, options()).await,
+        Err(NativeError::InvalidOptions(_))
+    ));
+}
+
+#[cfg(target_os = "linux")]
+#[tokio::test]
+async fn installed_launcher_sets_the_actual_startup_directory() {
+    let directory = std::env::temp_dir().canonicalize().unwrap();
+    let launch = command("startup_cwd")
+        .with_working_directory(&directory)
+        .unwrap();
+    let client = NativeClient::connect(launch, options()).await.unwrap();
+    let mut session = client
+        .new_session(SessionOptions::new(&directory))
+        .await
+        .unwrap();
+    let mut events = session.take_events().unwrap();
+    session.handle().prompt(prompt("cwd")).await.unwrap();
+    assert_eq!(text(&events.recv().await.unwrap()), directory.to_str());
+    client.close().await.unwrap();
+}
+
+#[cfg(target_os = "linux")]
+fn pid_fixture(mode: &str) -> (AgentCommand, PathBuf) {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static NEXT: AtomicU64 = AtomicU64::new(1);
+    let path = std::env::temp_dir().join(format!(
+        "ccht-native-pids-{}-{}.json",
+        std::process::id(),
+        NEXT.fetch_add(1, Ordering::Relaxed)
+    ));
+    let mut command = command(mode);
+    command.args.push(path.to_str().unwrap().into());
+    (command, path)
+}
+
+#[cfg(target_os = "linux")]
+async fn fixture_pids(path: &std::path::Path) -> Vec<u32> {
+    timeout(Duration::from_secs(5), async {
+        loop {
+            if let Ok(bytes) = std::fs::read(path)
+                && let Ok(pids) = serde_json::from_slice::<BTreeMap<String, u32>>(&bytes)
+            {
+                return pids.into_values().collect();
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .unwrap()
+}
+
+#[cfg(target_os = "linux")]
+async fn assert_processes_stopped(pids: &[u32]) {
+    timeout(Duration::from_secs(5), async {
+        loop {
+            let running = pids.iter().any(|pid| {
+                std::fs::read_to_string(format!("/proc/{pid}/stat")).is_ok_and(|stat| {
+                    // A zombie is terminated; reaping an orphan belongs to the
+                    // worker's init process, not to the client under test.
+                    !stat
+                        .rsplit_once(") ")
+                        .is_some_and(|(_, fields)| fields.starts_with('Z'))
+                })
+            });
+            if !running {
+                return;
+            }
+            tokio::time::sleep(Duration::from_millis(10)).await;
+        }
+    })
+    .await
+    .expect("SDK must terminate the agent and its descendant");
+}
+
+#[cfg(target_os = "linux")]
+#[tokio::test]
+async fn ignored_cancellation_really_terminates_the_sdk_process_group() {
+    let (launch, path) = pid_fixture("ignore_cancel");
+    let mut limits = options();
+    limits.shutdown_timeout = Duration::from_millis(100);
+    let client = NativeClient::connect(launch, limits).await.unwrap();
+    let pids = fixture_pids(&path).await;
+    let mut session = client
+        .new_session(SessionOptions::new(std::env::temp_dir()))
+        .await
+        .unwrap();
+    let handle = session.handle();
+    let mut events = session.take_events().unwrap();
+    let running = tokio::spawn({
+        let handle = handle.clone();
+        async move { handle.prompt(prompt("stop-processes")).await }
+    });
+    events.recv().await.unwrap();
+    assert_eq!(handle.cancel().await.unwrap_err(), NativeError::Timeout);
+    assert!(running.await.unwrap().is_err());
+    assert_processes_stopped(&pids).await;
+    let _ = std::fs::remove_file(path);
+}
+
+#[cfg(target_os = "linux")]
+#[tokio::test]
+async fn dropping_connect_during_initialization_really_terminates_its_children() {
+    let (launch, path) = pid_fixture("slow_init");
+    let connecting = tokio::spawn(NativeClient::connect(launch, options()));
+    let pids = fixture_pids(&path).await;
+    connecting.abort();
+    let _ = connecting.await;
+    assert_processes_stopped(&pids).await;
+    let _ = std::fs::remove_file(path);
+}

package/source/src/web.rs

@@ -0,0 +1,35 @@
+//! Browser bindings for the same conversation state used by native consumers.
+
+use wasm_bindgen::prelude::*;
+
+/// A Rust conversation model exported to JavaScript. The application owns transport.
+#[wasm_bindgen(js_name = ConversationModel)]
+pub struct WebConversation {
+    inner: crate::Conversation,
+}
+
+#[wasm_bindgen(js_class = ConversationModel)]
+impl WebConversation {
+    /// Create an isolated conversation state.
+    #[wasm_bindgen(constructor)]
+    pub fn new(conversation_id: String) -> Self {
+        Self {
+            inner: crate::Conversation::new(conversation_id),
+        }
+    }
+
+    /// Apply an event and report whether it changed the state.
+    #[wasm_bindgen(js_name = applyEvent)]
+    pub fn apply_event(&mut self, event_json: &str) -> Result<bool, JsValue> {
+        self.inner
+            .apply_json(event_json)
+            .map_err(|error| JsValue::from_str(&error.to_string()))
+    }
+
+    /// Return the current render state as JSON.
+    pub fn snapshot(&self) -> Result<String, JsValue> {
+        self.inner
+            .snapshot_json()
+            .map_err(|error| JsValue::from_str(&error.to_string()))
+    }
+}

package/wasm/ccht.d.ts

@@ -0,0 +1,60 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * A Rust conversation model exported to JavaScript. The application owns transport.
+ */
+export class ConversationModel {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Apply an event and report whether it changed the state.
+     */
+    applyEvent(event_json: string): boolean;
+    /**
+     * Create an isolated conversation state.
+     */
+    constructor(conversation_id: string);
+    /**
+     * Return the current render state as JSON.
+     */
+    snapshot(): string;
+}
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_conversationmodel_free: (a: number, b: number) => void;
+    readonly conversationmodel_applyEvent: (a: number, b: number, c: number) => [number, number, number];
+    readonly conversationmodel_new: (a: number, b: number) => number;
+    readonly conversationmodel_snapshot: (a: number) => [number, number, number, number];
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;