second-brain-cli 0.12.0

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

use anyhow::{Context, Result};

use super::ingest::{INGEST_QUEUED, queued_reason};
use crate::{api, bins, claude_hooks, claude_mcp, daemon, launchd};

pub(crate) fn cmd_setup() -> Result<()> {
    let os = daemon::Os::current();
    let caller = daemon::Caller::current();
    daemon::check_setup_caller(os, caller.uid)?;
    let account = match os {
        daemon::Os::MacOs => Some(launchd::Account::from_uid(caller.uid)?),
        daemon::Os::Linux => None,
    };
    let home = match &account {
        Some(account) => account.home.clone(),
        None => PathBuf::from(std::env::var("HOME").context("HOME not set")?),
    };

    let unit_active =
        os == daemon::Os::Linux && daemon::user_unit_active(&caller, &mut daemon::SystemExec);
    daemon::check_bind_free(
        daemon::DEFAULT_BIND,
        || match os {
            daemon::Os::Linux => Ok(unit_active),
            daemon::Os::MacOs => launchd::is_loaded(
                &launchd::Daemon::new(launchd::DEFAULT_LABEL),
                &mut launchd::System,
            ),
        },
        |port| daemon::port_holder(port, &mut daemon::SystemExec),
    )?;

    eprintln!("=== second-brain setup ===\n");

    // 1. Create data directory
    let db_dir = home.join(".second-brain");
    std::fs::create_dir_all(&db_dir)?;
    eprintln!("[1/6] data dir: {}", db_dir.display());

    // 2. Locate binaries
    let (api_bin, mcp_bin, cli_bin) = bins::locate_binaries()?;
    eprintln!("[2/6] binaries:");
    eprintln!("  api: {}", api_bin.display());
    eprintln!("  mcp: {}", mcp_bin.display());
    eprintln!("  cli: {}", cli_bin.display());

    let db_path = db_dir.join("brain.db");
    let record = match &account {
        Some(account) => install_launchd(account, &api_bin, &db_path, &db_dir, &caller)?,
        None => install_systemd(&home, &api_bin, &db_path, unit_active, &caller)?,
    };

    let mcp = claude_mcp::register(&mcp_bin, &mut daemon::SystemExec)?;
    eprintln!("[4/6] claude code MCP: {}", mcp.report());

    let settings =
        claude_hooks::settings_path(std::env::var_os("CLAUDE_CONFIG_DIR").as_deref(), &home);
    match claude_hooks::register(&settings, &cli_bin) {
        Ok(hooks) => eprintln!("[5/6] claude code hooks: {}", hooks.report()),
        Err(e) => eprintln!("[5/6] claude code hooks: warning: {e:#}"),
    }

    // 6. Wait for daemon, run first ingest
    eprintln!("[6/6] running first ingest...");
    let api = api::base_url();
    let probe = api::open_client(std::time::Duration::from_secs(2))?;
    let started = std::time::Instant::now();
    let ready = wait_for_daemon(
        || started.elapsed(),
        || {
            readiness(
                probe
                    .get(format!("{api}/health"))
                    .send()
                    .ok()
                    .map(|r| (r.status().as_u16(), r.json().unwrap_or_default())),
            )
        },
        std::thread::sleep,
        |waited, reason| match reason {
            Some(reason) => eprintln!(
                "  waiting for the daemon to finish starting ({}s): {reason}",
                waited.as_secs()
            ),
            None => eprintln!(
                "  waiting for the daemon to finish starting ({}s)",
                waited.as_secs()
            ),
        },
    );

    if !ready {
        eprintln!(
            "  the daemon is still starting after {}s; check it with `sb status` and run `sb ingest` once it is up",
            READY_LIMIT.as_secs()
        );
        return Ok(());
    }

    let client = api::client(std::time::Duration::from_secs(600))?;
    match client
        .post(format!("{api}/v1/ingest"))
        .json(&serde_json::json!({}))
        .send()
    {
        Ok(resp) if resp.status().is_success() => {
            let body: serde_json::Value = resp.json().unwrap_or_default();
            if queued_reason(&body).is_some() {
                eprintln!("  {INGEST_QUEUED}");
            } else {
                eprintln!(
                    "  ingested: {} memories, {} conversations",
                    body["new_memories"], body["new_conversations"]
                );
            }
        }
        Ok(resp) => eprintln!("  ingest warning: {}", resp.status()),
        Err(e) => eprintln!("  ingest warning: {e}"),
    }

    eprintln!("\n=== setup complete ===");
    eprintln!("daemon:  {}", daemon::status_hint(&record));
    eprintln!("recall:  sb recall \"your query\"");
    eprintln!("status:  sb status");

    Ok(())
}

fn install_systemd(
    home: &Path,
    api_bin: &Path,
    db_path: &Path,
    unit_active: bool,
    caller: &daemon::Caller,
) -> Result<daemon::ServiceRecord> {
    let systemd_dir = daemon::user_unit_dir(home);
    std::fs::create_dir_all(&systemd_dir)?;
    let service_path = systemd_dir.join(daemon::DEFAULT_UNIT);

    let service_content = daemon::unit_file(api_bin, db_path);

    std::fs::write(&service_path, &service_content)?;
    let record = daemon::ServiceRecord::user_default();
    daemon::save_record(&daemon::record_path()?, &record)?;
    eprintln!("[3/6] systemd service: {}", service_path.display());

    let mut exec = daemon::SystemExec;
    match daemon::start_user_unit(unit_active, caller, &mut exec) {
        daemon::Start::Started => eprintln!("  enabled and started"),
        daemon::Start::Restarted => eprintln!("  enabled and restarted on the new binary"),
        daemon::Start::Failed { command, detail } => eprintln!(
            "  warning: `{command}` failed ({detail}); start the daemon manually: {}",
            api_bin.display()
        ),
    }

    let user = launchd::Account::from_uid(caller.uid)
        .map(|account| account.name)
        .unwrap_or_else(|_| caller.uid.to_string());
    match daemon::ensure_linger(&user, &mut exec) {
        daemon::Linger::AlreadyOn => {}
        daemon::Linger::Enabled => {
            eprintln!("  linger enabled, so the daemon keeps running after logout")
        }
        daemon::Linger::Failed(warning) => eprintln!("  warning: {warning}"),
    }
    Ok(record)
}

const READY_LIMIT: std::time::Duration = std::time::Duration::from_secs(300);

const READY_PROGRESS: std::time::Duration = std::time::Duration::from_secs(15);

const READY_POLL: std::time::Duration = std::time::Duration::from_millis(500);

#[derive(Debug, PartialEq, Eq)]
enum Readiness {
    Ready,
    Starting(String),
    Down,
}

/// `answered` is the `/health` status and JSON body, None when nothing
/// answered.
fn readiness(answered: Option<(u16, serde_json::Value)>) -> Readiness {
    match answered {
        Some((200, health)) => match api::starting_reason(&health) {
            Some(reason) => Readiness::Starting(reason.to_string()),
            None => Readiness::Ready,
        },
        _ => Readiness::Down,
    }
}

/// The daemon serves `/health` with state "starting" while it opens the store
/// and rebuilds indexes, which can take minutes on a large store.
fn wait_for_daemon(
    mut elapsed: impl FnMut() -> std::time::Duration,
    mut probe: impl FnMut() -> Readiness,
    mut pause: impl FnMut(std::time::Duration),
    mut progress: impl FnMut(std::time::Duration, Option<&str>),
) -> bool {
    let mut next_report = READY_PROGRESS;
    loop {
        let reason = match probe() {
            Readiness::Ready => return true,
            Readiness::Starting(reason) => Some(reason),
            Readiness::Down => None,
        };
        let waited = elapsed();
        if waited >= READY_LIMIT {
            return false;
        }
        if waited >= next_report {
            progress(next_report, reason.as_deref());
            next_report += READY_PROGRESS;
        }
        pause(READY_POLL);
    }
}

fn install_launchd(
    account: &launchd::Account,
    api_bin: &Path,
    db_path: &Path,
    data_dir: &Path,
    caller: &daemon::Caller,
) -> Result<daemon::ServiceRecord> {
    let target = launchd::Daemon::new(launchd::DEFAULT_LABEL);
    let plist = launchd::render_plist(&launchd::PlistSpec {
        label: &target.label,
        program: api_bin,
        account,
        db: db_path,
        bind: daemon::DEFAULT_BIND,
    })?;
    eprintln!(
        "[3/6] launchd daemon: {} (sudo asks for your password)",
        target.plist.display()
    );
    launchd::install(
        &launchd::Install {
            daemon: &target,
            plist: &plist,
            staged: &data_dir.join(format!("{}.plist", target.label)),
            backup: &data_dir.join(format!("{}.plist.previous", target.label)),
            log_dir: &account.log_dir(),
            record_path: &daemon::record_path()?,
        },
        caller,
        &mut launchd::System,
    )?;
    eprintln!("  loaded, logs in {}", account.log_dir().display());
    Ok(target.record())
}

#[cfg(test)]
mod wait_tests {
    use std::cell::{Cell, RefCell};
    use std::time::Duration;

    use super::*;

    fn simulate(
        mut probe: impl FnMut(Duration) -> Readiness,
    ) -> (bool, Vec<(Duration, Option<String>)>, Duration) {
        let clock = Cell::new(Duration::ZERO);
        let reports = RefCell::new(Vec::new());
        let ready = wait_for_daemon(
            || clock.get(),
            || probe(clock.get()),
            |d| clock.set(clock.get() + d),
            |at, reason| reports.borrow_mut().push((at, reason.map(str::to_string))),
        );
        (ready, reports.into_inner(), clock.get())
    }

    fn ready_at(at: Duration) -> impl FnMut(Duration) -> Readiness {
        move |now| {
            if now >= at {
                Readiness::Ready
            } else {
                Readiness::Down
            }
        }
    }

    #[test]
    fn a_cold_start_is_waited_out_for_five_minutes_with_progress_every_fifteen_seconds() {
        let (ready, reports, stopped) = simulate(|_| Readiness::Down);
        assert!(!ready);
        assert!(stopped >= Duration::from_secs(300), "{stopped:?}");
        assert!(stopped < Duration::from_secs(301), "{stopped:?}");
        let expected: Vec<_> = (1..20)
            .map(|n| (Duration::from_secs(15 * n), None))
            .collect();
        assert_eq!(reports, expected);
    }

    #[test]
    fn a_daemon_that_comes_up_ends_the_wait() {
        let (ready, reports, stopped) = simulate(ready_at(Duration::from_secs(40)));
        assert!(ready);
        assert_eq!(
            reports,
            [
                (Duration::from_secs(15), None),
                (Duration::from_secs(30), None)
            ]
        );
        assert!(stopped < Duration::from_secs(41), "{stopped:?}");
    }

    #[test]
    fn a_starting_daemon_is_waited_for_with_its_reason_in_the_progress_line() {
        let (ready, reports, stopped) = simulate(|now| {
            if now >= Duration::from_secs(40) {
                Readiness::Ready
            } else {
                Readiness::Starting(format!(
                    "rebuilding search indexes for 23594 memories, {}s so far",
                    now.as_secs()
                ))
            }
        });
        assert!(ready);
        assert!(stopped >= Duration::from_secs(40), "{stopped:?}");
        assert!(stopped < Duration::from_secs(41), "{stopped:?}");
        assert_eq!(
            reports,
            [
                (
                    Duration::from_secs(15),
                    Some("rebuilding search indexes for 23594 memories, 15s so far".to_string())
                ),
                (
                    Duration::from_secs(30),
                    Some("rebuilding search indexes for 23594 memories, 30s so far".to_string())
                ),
            ]
        );
    }

    #[test]
    fn a_daemon_still_starting_after_the_limit_is_not_ready() {
        let (ready, _, stopped) =
            simulate(|_| Readiness::Starting("opening the database".to_string()));
        assert!(!ready);
        assert!(stopped >= Duration::from_secs(300), "{stopped:?}");
    }

    #[test]
    fn health_is_ready_only_when_it_answers_200_and_is_not_starting() {
        let reason = "rebuilding search indexes for 23594 memories, 212s so far";
        let starting = serde_json::json!({
            "status": "starting",
            "version": "0.12.0",
            "state": "starting",
            "reason": reason,
            "since": "2026-11-02T08:00:00Z",
            "serving": {"state": "starting", "reason": reason}
        });
        let ok = serde_json::json!({"status": "ok", "state": "ok", "serving": {"state": "ok"}});
        let failing = serde_json::json!({"status": "ok", "state": "failing", "reason": "x"});
        let cases = [
            (
                Some((200, starting)),
                Readiness::Starting(reason.to_string()),
            ),
            (Some((200, ok)), Readiness::Ready),
            (Some((200, failing)), Readiness::Ready),
            (Some((200, serde_json::Value::Null)), Readiness::Ready),
            (
                Some((
                    503,
                    serde_json::json!({"error": "the daemon is starting: x"}),
                )),
                Readiness::Down,
            ),
            (None, Readiness::Down),
        ];
        for (answered, expected) in cases {
            assert_eq!(readiness(answered.clone()), expected, "{answered:?}");
        }
    }
}