second-brain-cli 0.13.5

Memory layer for AI coding agents: ingest, recall, and sync across machines
mod common;

use std::process::{Command, Output, Stdio};

use common::{Answer, Daemon, Home, daemon};
use second_brain_sync::protocol::{Hello, SyncHeader};

const PINNED: &str = "pinned-device";

fn hello(id: &str) -> Hello {
    Hello {
        machine_id: id.to_string(),
        wall_micros: 0,
        synced: true,
        cursor: None,
        held_origin_seq: None,
        keys: None,
        peer_in: None,
        log_floor: 0,
        head: 0,
        applied: None,
        merging: None,
    }
}

fn devices(revoked: bool) -> String {
    serde_json::json!({
        "identity": "x",
        "devices": [{"machine_id": PINNED, "name": "p", "this_device": false, "revoked": revoked, "added_by": "x"}]
    })
    .to_string()
}

fn active(path: &str) -> (u16, String) {
    match path {
        "/v1/devices" => (200, devices(false)),
        "/health" => (200, r#"{"machine_id":"daemon-local-id"}"#.to_string()),
        "/v1/sync/version" => (200, serde_json::to_string(&SyncHeader::local()).unwrap()),
        _ => (404, r#"{"error":"unexpected"}"#.to_string()),
    }
}

fn revoked(path: &str) -> (u16, String) {
    match path {
        "/v1/devices" => (200, devices(true)),
        _ => active(path),
    }
}

fn serve(daemon: &Daemon, machine: &str, original: Option<&str>) -> Output {
    let home = Home::new();
    let mut command = Command::new(env!("CARGO_BIN_EXE_sb"));
    command
        .args(["sync-serve", "--machine", machine])
        .env("HOME", home.path())
        .env("SECOND_BRAIN_API", &daemon.base)
        .env("SECOND_BRAIN_BIND", "127.0.0.1:9")
        .env_remove("SSH_ORIGINAL_COMMAND")
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());
    if let Some(original) = original {
        command.env("SSH_ORIGINAL_COMMAND", original);
    }
    command.output().unwrap()
}

fn paths(daemon: &Daemon) -> Vec<String> {
    daemon
        .requests()
        .iter()
        .map(|r| r.target.split_whitespace().nth(1).unwrap().to_string())
        .collect()
}

#[test]
fn a_refused_command_exits_non_zero_without_reaching_the_daemon() {
    let d = daemon(Answer::Routed(active));
    for original in [
        None,
        Some(""),
        Some("sync-status"),
        Some("sb sync-trust x"),
        Some("sh -c whoami"),
        Some("sb whoami extra"),
    ] {
        let out = serve(&d, PINNED, original);
        assert!(!out.status.success(), "{original:?}");
        let stderr = String::from_utf8_lossy(&out.stderr);
        assert!(stderr.contains("sync-snapshot"), "{original:?}: {stderr}");
    }
    assert!(d.requests().is_empty(), "{:?}", paths(&d));
}

#[test]
fn a_bad_machine_argument_is_a_usage_error() {
    let d = daemon(Answer::Routed(active));
    let out = serve(&d, "bad id;", Some("whoami"));
    assert!(!out.status.success());
    assert!(String::from_utf8_lossy(&out.stderr).contains("usage"));
    assert!(d.requests().is_empty());
}

#[test]
fn whoami_for_an_active_pinned_device_reads_the_daemon_health() {
    let d = daemon(Answer::Routed(active));
    let out = serve(&d, PINNED, Some("/home/x/.cargo/bin/sb whoami"));
    assert!(
        out.status.success(),
        "{}",
        String::from_utf8_lossy(&out.stderr)
    );
    assert_eq!(String::from_utf8_lossy(&out.stdout), "daemon-local-id\n");
    assert_eq!(paths(&d), ["/v1/devices", "/health"]);
}

#[test]
fn an_export_hello_naming_another_machine_never_reaches_sync_export() {
    let d = daemon(Answer::Routed(active));
    let original = format!(
        "sb sync-export --after-seq 0 --hello {}",
        hello("other").to_arg()
    );
    let out = serve(&d, PINNED, Some(&original));
    assert!(!out.status.success());
    assert!(String::from_utf8_lossy(&out.stderr).contains("other"));
    assert!(
        !paths(&d).iter().any(|p| p == "/v1/sync/export"),
        "{:?}",
        paths(&d)
    );
}

#[test]
fn an_export_hello_naming_the_pinned_machine_is_forwarded() {
    let d = daemon(Answer::Routed(|path| match path {
        "/v1/sync/export" => (200, r#"{"lines":[],"max_seq":0}"#.to_string()),
        other => active(other),
    }));
    let original = format!(
        "sb sync-export --after-seq 0 --hello {}",
        hello(PINNED).to_arg()
    );
    let out = serve(&d, PINNED, Some(&original));
    assert!(
        out.status.success(),
        "{}",
        String::from_utf8_lossy(&out.stderr)
    );
    assert!(paths(&d).iter().any(|p| p == "/v1/sync/export"));
}

#[test]
fn a_revoked_pinned_device_is_refused_before_any_command_runs() {
    let d = daemon(Answer::Routed(revoked));
    let out = serve(&d, PINNED, Some("sb whoami"));
    assert!(!out.status.success());
    assert!(String::from_utf8_lossy(&out.stderr).contains("revoked"));
    assert_eq!(paths(&d), ["/v1/devices"]);
}

#[test]
fn an_unlisted_pinned_device_is_refused() {
    let d = daemon(Answer::Routed(active));
    let out = serve(&d, "someone-else", Some("sb whoami"));
    assert!(!out.status.success());
    assert!(String::from_utf8_lossy(&out.stderr).contains("not paired"));
    assert_eq!(paths(&d), ["/v1/devices"]);
}

#[test]
fn an_import_stream_naming_another_machine_is_refused_before_the_daemon_imports() {
    let d = daemon(Answer::Routed(active));
    let header = SyncHeader {
        hello: Some(hello("other")),
        ..SyncHeader::local()
    };
    let home = Home::new();
    let mut child = Command::new(env!("CARGO_BIN_EXE_sb"))
        .args(["sync-serve", "--machine", PINNED])
        .env("HOME", home.path())
        .env("SECOND_BRAIN_API", &d.base)
        .env("SSH_ORIGINAL_COMMAND", "sb sync-import")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    {
        use std::io::Write;
        let mut stdin = child.stdin.take().unwrap();
        writeln!(stdin, "{}", header.to_line()).unwrap();
    }
    let out = child.wait_with_output().unwrap();
    assert!(!out.status.success());
    assert!(
        !paths(&d).iter().any(|p| p == "/v1/sync/import"),
        "{:?}",
        paths(&d)
    );
}