second-brain-cli 0.13.5

Memory layer for AI coding agents: ingest, recall, and sync across machines
use std::io::Write;
use std::process::{Command, Output, Stdio};

use second_brain_sync::crypto::{XChaChaEncryptor, seal_line};
use second_brain_sync::protocol::{SYNC_PROTOCOL_VERSION, SyncHeader};

const KEY: [u8; 32] = [1; 32];

fn sync_import(stdin: &str) -> Output {
    let home = tempfile::tempdir().unwrap();
    second_brain_core::api_token::ensure(&home.path().join(".second-brain")).unwrap();
    let mut child = Command::new(env!("CARGO_BIN_EXE_sb"))
        .arg("sync-import")
        .env("HOME", home.path())
        .env("SECOND_BRAIN_API", "http://127.0.0.1:9")
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .unwrap();
    child
        .stdin
        .take()
        .unwrap()
        .write_all(stdin.as_bytes())
        .unwrap();
    child.wait_with_output().unwrap()
}

fn sealed_record() -> String {
    seal_line(
        &XChaChaEncryptor::new(KEY),
        br#"{"local_seq":1,"origin_machine_id":"m","origin_seq":1,"op":"create","node_type":"memory","node_id":"x","timestamp":"2026-01-01T00:00:00Z","data":null}"#,
    )
    .unwrap()
}

fn assert_refused(output: &Output, expected: &str) {
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(!output.status.success(), "{stderr}");
    assert!(stderr.contains(expected), "{stderr}");
    assert!(
        !stderr.contains("local daemon"),
        "the stream must be refused before anything reaches the daemon: {stderr}"
    );
}

#[test]
fn a_headerless_export_from_an_old_peer_is_refused() {
    let output = sync_import(&format!("{}\n", sealed_record()));
    assert_refused(&output, "declared no sync version");
}

#[test]
fn an_empty_stream_is_refused() {
    assert_refused(&sync_import(""), "declared no sync version");
}

#[test]
fn a_stream_with_another_protocol_is_refused() {
    let header = SyncHeader {
        sync_protocol: SYNC_PROTOCOL_VERSION + 1,
        ..SyncHeader::local()
    };
    let output = sync_import(&format!("{}\n{}\n", header.to_line(), sealed_record()));
    assert_refused(&output, "upgrade this machine");
}

#[test]
fn a_stream_with_another_schema_is_refused() {
    let local = SyncHeader::local();
    let header = SyncHeader {
        schema_version: local.schema_version - 1,
        ..local
    };
    let output = sync_import(&format!("{}\n{}\n", header.to_line(), sealed_record()));
    assert_refused(&output, "upgrade the sender");
}

#[test]
fn a_matching_stream_gets_past_the_header_check() {
    let output = sync_import(&format!(
        "{}\n{}\n",
        SyncHeader::local().to_line(),
        sealed_record()
    ));
    let stderr = String::from_utf8_lossy(&output.stderr);
    assert!(
        stderr.contains("asking the local daemon for its sync version"),
        "a matching stream goes on to the daemon's version check: {stderr}"
    );
}