use anyhow::{Context, Result};
use second_brain_sync::peers;
use second_brain_sync::protocol::SyncHeader;
use second_brain_sync::session::{self, Exported, Imported, Local, read_checked_header};
use second_brain_sync::ssh::SshTransport;
use serde_json::Value;
use crate::api;
pub(crate) fn cmd_sync_trust(host: &str) -> Result<()> {
use std::io::Write;
let scan = std::process::Command::new("ssh-keyscan")
.arg("-T")
.arg("10")
.arg(host)
.output()
.context("running ssh-keyscan (is openssh-client installed?)")?;
if !scan.status.success() {
let stderr = String::from_utf8_lossy(&scan.stderr);
anyhow::bail!(
"ssh-keyscan {host} failed (exit {}): {}",
scan.status,
stderr.trim()
);
}
let raw = String::from_utf8(scan.stdout).context("ssh-keyscan returned non-UTF8 output")?;
let lines = second_brain_sync::ssh::parse_keyscan_output(&raw);
if lines.is_empty() {
anyhow::bail!("ssh-keyscan {host} returned no host keys — host unreachable or filtered");
}
let canonical: String = lines
.iter()
.map(second_brain_sync::ssh::compose_known_host_entry)
.collect();
let mut fp_child = std::process::Command::new("ssh-keygen")
.arg("-lf")
.arg("-")
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::inherit())
.spawn()
.context("running ssh-keygen (is openssh-client installed?)")?;
{
let stdin = fp_child.stdin.take().unwrap();
let mut writer = std::io::BufWriter::new(stdin);
writer.write_all(canonical.as_bytes())?;
}
let fp_out = fp_child.wait_with_output()?;
if !fp_out.status.success() {
anyhow::bail!("ssh-keygen -lf failed: exit {}", fp_out.status);
}
let fingerprints = String::from_utf8_lossy(&fp_out.stdout);
eprintln!("Host: {host}");
eprintln!("Fetched {} key(s). Fingerprints:", lines.len());
for fp_line in fingerprints.lines() {
eprintln!(" {fp_line}");
}
eprintln!();
eprintln!("Verify these fingerprints out-of-band before trusting them.");
eprint!("Pin to ~/.second-brain/known_hosts? [y/N] ");
std::io::stderr().flush().ok();
let mut answer = String::new();
std::io::stdin()
.read_line(&mut answer)
.context("reading confirmation")?;
let trimmed = answer.trim();
if !trimmed.eq_ignore_ascii_case("y") && !trimmed.eq_ignore_ascii_case("yes") {
eprintln!("aborted; nothing written.");
return Ok(());
}
let path = second_brain_sync::ssh::known_hosts_path()?;
second_brain_sync::ssh::append_known_host(&path, &lines)?;
eprintln!(
"pinned {} key(s) for {host} -> {}",
lines.len(),
path.display()
);
Ok(())
}
pub(crate) fn cmd_sync_export(after_seq: u64) -> Result<()> {
let api_base = api::base_url();
let client = api::sync_client(std::time::Duration::from_secs(120))?;
#[derive(serde::Deserialize)]
struct ExportResp {
records: Vec<serde_json::Value>,
max_seq: u64,
}
const BATCH_SIZE: usize = 2000;
let encryptor = default_sync_encryptor()?;
let stdout = std::io::stdout();
let mut writer = std::io::BufWriter::new(stdout.lock());
let mut cursor = after_seq;
let mut total = 0u64;
let mut header_written = false;
loop {
use std::io::Write;
let resp: ExportResp = api::daemon_ok(
client
.post(format!("{api_base}/v1/sync/export"))
.json(&export_request(cursor, BATCH_SIZE))
.send()
.context("calling sync/export on daemon")?,
)
.context("sync/export returned error")?
.json()?;
if !header_written {
writeln!(writer, "{}", SyncHeader::local().to_line())?;
writer.flush()?;
header_written = true;
}
if resp.records.is_empty() {
break;
}
let batch_count = resp.records.len();
for record in &resp.records {
let plaintext = serde_json::to_vec(record)?;
let line = second_brain_sync::crypto::seal_line(&encryptor, &plaintext)?;
writer.write_all(line.as_bytes())?;
writer.write_all(b"\n")?;
}
writer.flush()?;
total += batch_count as u64;
cursor = resp.max_seq;
if batch_count < BATCH_SIZE {
break;
}
}
eprintln!("exported {total} records through seq {cursor}");
Ok(())
}
pub(crate) fn cmd_sync_key() -> Result<()> {
let path = second_brain_sync::crypto::default_key_path()?;
let key = second_brain_sync::crypto::load_or_create_key(&path)?;
let enc = second_brain_sync::crypto::XChaChaEncryptor::new(key);
println!("{}", enc.key_base64());
eprintln!("key file: {}", path.display());
eprintln!(
"copy this base64 value into ~/.second-brain/sync.key on each paired device \
(run `sb sync-key` once on a device to generate, then replicate it everywhere)."
);
Ok(())
}
pub(crate) fn cmd_sync_import() -> Result<()> {
const BATCH_SIZE: usize = 500;
let stdin = std::io::stdin();
let mut reader = std::io::BufReader::new(stdin.lock());
let header = read_checked_header(&mut reader, "the sender")?;
let api_base = api::base_url();
let client = api::sync_client(std::time::Duration::from_secs(600))?;
#[derive(serde::Deserialize)]
struct ImportResp {
created: u64,
updated: u64,
deleted: u64,
skipped: u64,
errors: u64,
max_seq: u64,
}
let mut totals = (0u64, 0u64, 0u64, 0u64, 0u64, 0u64);
let mut batch: Vec<serde_json::Value> = Vec::with_capacity(BATCH_SIZE);
let mut min_error_watermark: Option<u64> = None;
let flush_batch = |batch: &mut Vec<serde_json::Value>,
totals: &mut (u64, u64, u64, u64, u64, u64),
min_error_watermark: &mut Option<u64>|
-> Result<()> {
if batch.is_empty() {
return Ok(());
}
let resp: ImportResp = api::daemon_ok(
client
.post(format!("{api_base}/v1/sync/import"))
.json(&serde_json::json!({"header": header, "records": *batch}))
.send()
.context("calling sync/import on daemon")?,
)
.context("sync/import returned error")?
.json()?;
totals.0 += resp.created;
totals.1 += resp.updated;
totals.2 += resp.deleted;
totals.3 += resp.skipped;
totals.4 += resp.errors;
if resp.errors > 0 {
let candidate = resp.max_seq.saturating_sub(1);
*min_error_watermark = Some(
min_error_watermark
.map(|prev| prev.min(candidate))
.unwrap_or(candidate),
);
} else {
totals.5 = totals.5.max(resp.max_seq);
}
batch.clear();
Ok(())
};
let encryptor = default_sync_encryptor()?;
for line in std::io::BufRead::lines(reader) {
let line = line?;
if line.trim().is_empty() {
continue;
}
let plaintext = second_brain_sync::crypto::open_line(&encryptor, &line)?;
batch.push(serde_json::from_slice(&plaintext)?);
if batch.len() >= BATCH_SIZE {
flush_batch(&mut batch, &mut totals, &mut min_error_watermark)?;
}
}
flush_batch(&mut batch, &mut totals, &mut min_error_watermark)?;
if let Some(err_wm) = min_error_watermark {
totals.5 = totals.5.min(err_wm);
}
eprintln!(
"imported: {} created, {} updated, {} deleted, {} skipped, {} errors (through seq {})",
totals.0, totals.1, totals.2, totals.3, totals.4, totals.5
);
Ok(())
}
pub(crate) fn cmd_sync_status() -> Result<()> {
let api_base = api::base_url();
let client = api::client(std::time::Duration::from_secs(30))?;
#[derive(serde::Deserialize)]
struct PeerInfo {
peers: Vec<PeerState>,
}
#[derive(serde::Deserialize)]
struct PeerState {
peer_id: String,
last_seq: u64,
last_sync_at: String,
}
let resp: PeerInfo = api::daemon_ok(
client
.get(format!("{api_base}/v1/sync/status"))
.send()
.context("getting sync status from daemon")?,
)?
.json()?;
if resp.peers.is_empty() {
println!("no sync peers configured");
} else {
for state in &resp.peers {
println!(
"peer: {}, last_seq: {}, last_sync: {}",
state.peer_id, state.last_seq, state.last_sync_at
);
}
}
Ok(())
}
pub(crate) fn cmd_sync_backfill() -> Result<()> {
let api_base = api::base_url();
let client = api::client(std::time::Duration::from_secs(30))?;
#[derive(serde::Deserialize)]
struct BackfillResp {
backfilled: usize,
#[serde(default)]
tombstones_backfilled: usize,
}
let resp: BackfillResp = api::daemon_ok(
client
.post(format!("{api_base}/v1/sync/backfill"))
.send()
.context("calling backfill on daemon")?,
)?
.json()?;
eprintln!(
"backfilled {} create entries, {} delete entries",
resp.backfilled, resp.tombstones_backfilled
);
Ok(())
}
pub(crate) fn cmd_sync_compact(ops: &[String], dry_run: bool) -> Result<()> {
let api_base = api::base_url();
let client = api::client(std::time::Duration::from_secs(30))?;
#[derive(serde::Deserialize)]
struct CompactResp {
groups_with_duplicates: u64,
rows_deleted: u64,
max_local_seq_before: u64,
max_local_seq_after: u64,
}
let resp: CompactResp = api::daemon_ok(
client
.post(format!("{api_base}/v1/sync/compact"))
.json(&serde_json::json!({"ops": ops, "dry_run": dry_run}))
.send()
.context("calling compact on daemon")?,
)?
.json()?;
if resp.max_local_seq_before != resp.max_local_seq_after {
anyhow::bail!(
"compact reported MAX(local_seq) moved from {} to {} -- aborting, this must never happen",
resp.max_local_seq_before,
resp.max_local_seq_after
);
}
if dry_run {
eprintln!(
"dry run: {} groups have duplicates, {} rows would be deleted (max_local_seq {} unaffected)",
resp.groups_with_duplicates, resp.rows_deleted, resp.max_local_seq_after
);
} else {
eprintln!(
"compacted {} groups, deleted {} duplicate rows (max_local_seq {} unchanged)",
resp.groups_with_duplicates, resp.rows_deleted, resp.max_local_seq_after
);
}
Ok(())
}
pub(crate) fn cmd_sync(peer_host: &str, args: &[String]) -> Result<()> {
let data_dir = second_brain_core::machine::data_dir()?;
let sb_binary = peer_sb(args, &data_dir, peer_host)?;
let local = DaemonApi {
client: api::sync_client(std::time::Duration::from_secs(600))?,
base: api::base_url(),
};
let transport = SshTransport::new(peer_host, &sb_binary)?;
let encryptor = default_sync_encryptor()?;
session::sync(&local, &transport, &encryptor, &data_dir, &|line| {
eprintln!("{line}")
})
}
fn peer_sb(args: &[String], data_dir: &std::path::Path, peer_host: &str) -> Result<String> {
let flag = args
.iter()
.position(|arg| arg == "--sb-path")
.and_then(|i| args.get(i + 1));
if let Some(sb) = flag {
return Ok(sb.clone());
}
Ok(peers::configured_peer(data_dir, peer_host)
.context("reading sync-peers")?
.map_or_else(|| "sb".to_string(), |peer| peer.sb))
}
struct DaemonApi {
client: reqwest::blocking::Client,
base: String,
}
impl Local for DaemonApi {
fn cursors(&self) -> Result<Vec<(String, u64)>> {
#[derive(serde::Deserialize)]
struct PeerInfo {
peers: Vec<PeerState>,
}
#[derive(serde::Deserialize)]
struct PeerState {
peer_id: String,
last_seq: u64,
}
let status: PeerInfo = self
.client
.get(format!("{}/v1/sync/status", self.base))
.send()?
.json()?;
Ok(status
.peers
.into_iter()
.map(|p| (p.peer_id, p.last_seq))
.collect())
}
fn set_cursor(&self, peer_id: &str, last_seq: u64) -> Result<()> {
self.client
.post(format!("{}/v1/sync/state", self.base))
.json(&serde_json::json!({"peer_id": peer_id, "last_seq": last_seq}))
.send()?;
Ok(())
}
fn import(&self, header: &SyncHeader, records: &[Value]) -> Result<Imported> {
#[derive(serde::Deserialize)]
struct ImportResp {
created: u64,
updated: u64,
deleted: u64,
skipped: u64,
max_seq: u64,
#[serde(default)]
skipped_by_reason: std::collections::BTreeMap<String, u64>,
}
let resp: ImportResp = api::daemon_ok(
self.client
.post(format!("{}/v1/sync/import", self.base))
.json(&serde_json::json!({"header": header, "records": records}))
.send()
.context("posting import to daemon")?,
)
.context("import returned error")?
.json()?;
Ok(Imported {
created: resp.created,
updated: resp.updated,
deleted: resp.deleted,
skipped: resp.skipped,
dangling: Imported::dangling_in(&resp.skipped_by_reason),
max_seq: resp.max_seq,
})
}
fn export(&self, after_seq: u64, limit: usize) -> Result<Exported> {
#[derive(serde::Deserialize)]
struct ExportResp {
records: Vec<Value>,
max_seq: u64,
}
let export: ExportResp = api::daemon_ok(
self.client
.post(format!("{}/v1/sync/export", self.base))
.json(&export_request(after_seq, limit))
.send()
.context("getting export from daemon")?,
)
.context("export returned error")?
.json()?;
Ok(Exported {
records: export.records,
max_seq: export.max_seq,
})
}
}
fn export_request(after_seq: u64, limit: usize) -> serde_json::Value {
serde_json::json!({"after_seq": after_seq, "limit": limit, "header": SyncHeader::local()})
}
fn default_sync_encryptor() -> Result<second_brain_sync::crypto::XChaChaEncryptor> {
let path = second_brain_sync::crypto::default_key_path()?;
let key = second_brain_sync::crypto::load_or_create_key(&path)?;
Ok(second_brain_sync::crypto::XChaChaEncryptor::new(key))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn sb_sync_finds_the_peers_sb_like_the_daemon_unless_told() {
let dir = tempfile::tempdir().unwrap();
let none: Vec<String> = Vec::new();
assert_eq!(peer_sb(&none, dir.path(), "user@pi").unwrap(), "sb");
std::fs::write(dir.path().join(peers::PEERS_FILE), "user@pi /opt/sb\n").unwrap();
assert_eq!(peer_sb(&none, dir.path(), "user@pi").unwrap(), "/opt/sb");
let flag = vec!["--sb-path".to_string(), "/usr/bin/sb".to_string()];
assert_eq!(
peer_sb(&flag, dir.path(), "user@pi").unwrap(),
"/usr/bin/sb"
);
}
}