supercode-cli 0.4.18

supercode — a lightweight, fully-customizable AI coding agent CLI in Rust. Any model via OpenRouter; natively continues Claude Code and Codex sessions.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

//! Process-level proof that the public human `attach` command can consume the
//! negotiated ACP frontend extension through the same line/TUI dispatcher as
//! HTTP, while the separately owned SDK runtime survives detachment.

use std::process::Stdio;
use std::sync::Arc;
use std::time::Duration;

use anyhow::Result;
use async_trait::async_trait;
use supercode::server::{run_http, RpcEngine};
use supercode::{Agent, ChatMessage, ChatRequest, Config, Provider, Usage};
use tokio::io::AsyncWriteExt;

fn bin() -> &'static str {
    env!("CARGO_BIN_EXE_supercode")
}

struct UnusedProvider;

#[async_trait]
impl Provider for UnusedProvider {
    async fn complete(
        &self,
        _request: &ChatRequest,
        _on_delta: &(dyn for<'a> Fn(&'a str) + Send + Sync),
    ) -> supercode::Result<(ChatMessage, Usage)> {
        panic!("detaching an ACP frontend must not call the model")
    }
}

#[tokio::test]
async fn public_attach_uses_acp_bridge_without_stopping_the_runtime() -> Result<()> {
    let cwd = std::env::temp_dir().join(format!("supercode-acp-attach-cli-{}", std::process::id()));
    std::fs::create_dir_all(&cwd)?;
    let agent = Agent::with_provider(
        Config::builder().cwd(cwd.clone()).build(),
        Box::new(UnusedProvider),
    );
    let runtime = RpcEngine::new_named(agent, "public-acp-attach", None);
    let token: Arc<str> = "acp-attach-test-token".into();
    let address = run_http(runtime.clone(), "127.0.0.1:0", token.clone()).await?;
    let url = format!("http://{address}");
    let supercode_home = cwd.join("supercode-home");

    for invocation in 1..=2 {
        let mut child = tokio::process::Command::new(bin())
            .current_dir(&cwd)
            .env("SUPERCODE_HOME", &supercode_home)
            .env("SUPERCODE_SERVER_TOKEN", token.as_ref())
            .arg("--bare")
            .arg("attach")
            .arg("--connect")
            .arg(&url)
            .arg("--acp")
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()?;
        let mut stdin = child.stdin.take().expect("attach stdin must be piped");
        stdin.write_all(b"/detach\n").await?;
        drop(stdin);

        let output = tokio::time::timeout(Duration::from_secs(30), child.wait_with_output())
            .await
            .expect("ACP attach command timed out")?;
        assert!(
            output.status.success(),
            "attach invocation {invocation} failed: stdout={} stderr={}",
            String::from_utf8_lossy(&output.stdout),
            String::from_utf8_lossy(&output.stderr)
        );
        let stdout = String::from_utf8_lossy(&output.stdout);
        assert!(stdout.contains("attached to public-acp-attach"), "{stdout}");
        assert!(
            stdout.contains("system>"),
            "bounded history was not rendered: {stdout}"
        );
        assert!(
            !runtime.is_shutting_down(),
            "ACP detach invocation {invocation} stopped its SDK-owned runtime"
        );
    }

    let checkpoint_dir = supercode_home.join("frontend-acp");
    let checkpoints = std::fs::read_dir(&checkpoint_dir)?.collect::<Result<Vec<_>, _>>()?;
    assert_eq!(checkpoints.len(), 1);
    let checkpoint: supercode::AcpFrontendCheckpoint =
        serde_json::from_slice(&std::fs::read(checkpoints[0].path())?)?;
    assert_eq!(checkpoint.session_id, "public-acp-attach");

    runtime.shutdown().await;
    std::fs::remove_dir_all(cwd).ok();
    Ok(())
}