second-brain-cli 0.13.5

Memory layer for AI coding agents: ingest, recall, and sync across machines
use std::path::{Path, PathBuf};
use std::process::{Command, Output};

const PACKAGES: [(&str, &str); 3] = [
    ("second-brain-api", "second-brain-api"),
    ("second-brain-mcp", "second-brain-mcp"),
    ("second-brain-cli", "sb"),
];

struct Fixture {
    _root: tempfile::TempDir,
    home: PathBuf,
    release: PathBuf,
    shims: PathBuf,
}

impl Fixture {
    fn new() -> Self {
        let root = tempfile::tempdir().unwrap();
        let home = root.path().join("home");
        let release = root.path().join("release");
        let shims = root.path().join("shims");
        for dir in [&home, &release, &shims] {
            std::fs::create_dir_all(dir).unwrap();
        }
        for (package, bin) in PACKAGES {
            write_installer(&release, package, bin, "setup-ok");
        }
        let curl = which("curl");
        write_executable(
            &shims.join("curl"),
            &format!(
                "#!/bin/sh\necho \"$*\" >> \"$HOME/downloads\"\nexec {} \"$@\"\n",
                curl.display()
            ),
        );
        write_executable(&shims.join("sysctl"), "#!/bin/sh\nexit 1\n");
        Fixture {
            _root: root,
            home,
            release,
            shims,
        }
    }

    fn cargo_bin(&self) -> PathBuf {
        self.home.join(".cargo/bin")
    }

    fn uname(&self, system: &str, machine: &str) {
        write_executable(
            &self.shims.join("uname"),
            &format!("#!/bin/sh\ncase \"$1\" in -s) echo {system} ;; -m) echo {machine} ;; esac\n"),
        );
    }

    fn arm64_hardware(&self) {
        write_executable(
            &self.shims.join("sysctl"),
            "#!/bin/sh\n[ \"$*\" = \"-n hw.optional.arm64\" ] && echo 1\n",
        );
    }

    fn run(&self) -> Output {
        self.run_with_cargo_home(None)
    }

    fn run_with_cargo_home(&self, cargo_home: Option<&Path>) -> Output {
        let script = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../scripts/install.sh");
        let path = format!(
            "{}:{}",
            self.shims.display(),
            std::env::var("PATH").unwrap_or_default()
        );
        let mut cmd = Command::new("sh");
        cmd.arg(script)
            .env_clear()
            .env("PATH", path)
            .env("HOME", &self.home)
            .env(
                "SECOND_BRAIN_RELEASE_URL",
                format!("file://{}", self.release.display()),
            );
        if let Some(dir) = cargo_home {
            cmd.env("CARGO_HOME", dir);
        }
        cmd.output().unwrap()
    }

    fn read(&self, name: &str) -> String {
        std::fs::read_to_string(self.home.join(name)).unwrap_or_default()
    }
}

fn which(name: &str) -> PathBuf {
    std::env::split_paths(&std::env::var_os("PATH").unwrap_or_default())
        .map(|dir| dir.join(name))
        .find(|path| path.is_file())
        .unwrap_or_else(|| panic!("{name} is not on PATH"))
}

fn write_executable(path: &Path, body: &str) {
    std::fs::write(path, body).unwrap();
    let mut perms = std::fs::metadata(path).unwrap().permissions();
    std::os::unix::fs::PermissionsExt::set_mode(&mut perms, 0o755);
    std::fs::set_permissions(path, perms).unwrap();
}

fn write_installer(release: &Path, package: &str, bin: &str, setup: &str) {
    let fake_bin = match setup {
        "setup-ok" => "echo \"$*\" >> \"$HOME/sb-calls\"",
        _ => "echo \"$*\" >> \"$HOME/sb-calls\"; exit 4",
    };
    let body = format!(
        "#!/bin/sh\nset -eu\n\
         dir=\"${{CARGO_HOME:-$HOME/.cargo}}/bin\"\n\
         mkdir -p \"$dir\"\n\
         printf '#!/bin/sh\\n%s\\n' '{fake_bin}' > \"$dir/{bin}\"\n\
         chmod +x \"$dir/{bin}\"\n\
         echo {package} >> \"$HOME/installers\"\n"
    );
    std::fs::write(release.join(format!("{package}-installer.sh")), body).unwrap();
}

fn stderr(out: &Output) -> String {
    String::from_utf8_lossy(&out.stderr).into_owned()
}

#[test]
fn installs_every_package_then_runs_setup_once() {
    let fx = Fixture::new();
    fx.uname("Linux", "x86_64");
    let out = fx.run();
    assert!(out.status.success(), "{}", stderr(&out));
    let mut installed: Vec<String> = fx.read("installers").lines().map(String::from).collect();
    installed.sort();
    assert_eq!(
        installed,
        ["second-brain-api", "second-brain-cli", "second-brain-mcp"]
    );
    assert_eq!(fx.read("sb-calls"), "setup\n");
    for (_, bin) in PACKAGES {
        assert!(fx.cargo_bin().join(bin).exists(), "{bin} not installed");
    }
}

#[test]
fn every_supported_platform_installs() {
    for (system, machine) in [
        ("Linux", "x86_64"),
        ("Linux", "aarch64"),
        ("Linux", "arm64"),
        ("Darwin", "arm64"),
    ] {
        let fx = Fixture::new();
        fx.uname(system, machine);
        let out = fx.run();
        assert!(out.status.success(), "{system} {machine}: {}", stderr(&out));
    }
}

#[test]
fn an_unsupported_platform_stops_before_downloading() {
    for (system, machine) in [
        ("Darwin", "x86_64"),
        ("FreeBSD", "amd64"),
        ("Linux", "armv7l"),
    ] {
        let fx = Fixture::new();
        fx.uname(system, machine);
        let out = fx.run();
        assert!(!out.status.success(), "{system} {machine} installed");
        assert!(
            stderr(&out).contains("no prebuilt release") && stderr(&out).contains("sb setup"),
            "{system} {machine}: {}",
            stderr(&out)
        );
        assert_eq!(fx.read("installers"), "");
        assert_eq!(fx.read("downloads"), "", "{system} {machine} downloaded");
    }
}

#[test]
fn an_apple_silicon_shell_under_rosetta_installs_the_arm64_release() {
    let fx = Fixture::new();
    fx.uname("Darwin", "x86_64");
    fx.arm64_hardware();
    let out = fx.run();
    assert!(out.status.success(), "{}", stderr(&out));
    assert_eq!(fx.read("sb-calls"), "setup\n");
}

#[test]
fn a_missing_installer_fails_without_running_setup() {
    let fx = Fixture::new();
    fx.uname("Linux", "x86_64");
    std::fs::remove_file(fx.release.join("second-brain-mcp-installer.sh")).unwrap();
    let out = fx.run();
    assert!(!out.status.success());
    assert!(
        stderr(&out).contains("second-brain-mcp-installer.sh"),
        "{}",
        stderr(&out)
    );
    assert_eq!(fx.read("sb-calls"), "");
    assert_eq!(fx.read("installers"), "");
}

#[test]
fn a_failing_setup_fails_the_install() {
    let fx = Fixture::new();
    fx.uname("Linux", "x86_64");
    write_installer(&fx.release, "second-brain-cli", "sb", "setup-fails");
    let out = fx.run();
    assert!(!out.status.success());
    assert_eq!(fx.read("sb-calls"), "setup\n");
    assert!(stderr(&out).contains("sb doctor"), "{}", stderr(&out));
}

#[test]
fn cargo_home_decides_where_setup_is_run_from() {
    let fx = Fixture::new();
    fx.uname("Linux", "x86_64");
    let cargo_home = fx.home.join("elsewhere");
    let out = fx.run_with_cargo_home(Some(&cargo_home));
    assert!(out.status.success(), "{}", stderr(&out));
    assert!(cargo_home.join("bin/sb").exists());
    assert_eq!(fx.read("sb-calls"), "setup\n");
}