@corbet-labs/ccht 0.1.0 → 0.2.2

package/source/src/native/tests.rs

@@ -1,427 +0,0 @@
-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

@@ -1,35 +0,0 @@
-//! 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()))
-    }
-}