second-brain-cli 0.13.5

Memory layer for AI coding agents: ingest, recall, and sync across machines
use std::time::Duration;

use anyhow::{Context, Result, bail};
use serde::Deserialize;

use crate::api;

const USAGE: &str =
    "usage: sb device list\n       sb device remove <name> [--keep <name>]... [--yes]";

#[derive(Debug, PartialEq, Eq)]
pub(crate) enum DeviceArgs {
    List,
    Remove {
        device: String,
        keep: Vec<String>,
        yes: bool,
    },
}

impl DeviceArgs {
    /// `args` are the words after `device`.
    pub(crate) fn parse(args: &[String]) -> Result<DeviceArgs> {
        match args.first().map(String::as_str) {
            Some("list") if args.len() == 1 => Ok(DeviceArgs::List),
            Some("remove") => {
                let mut device = None;
                let mut keep = Vec::new();
                let mut yes = false;
                let mut words = args[1..].iter();
                while let Some(word) = words.next() {
                    match word.as_str() {
                        "--keep" => keep.push(
                            words
                                .next()
                                .with_context(|| format!("--keep needs a device name\n{USAGE}"))?
                                .clone(),
                        ),
                        "--yes" => yes = true,
                        flag if flag.starts_with("--") => {
                            bail!("unexpected argument {flag:?}\n{USAGE}")
                        }
                        name if device.is_none() => device = Some(name.to_string()),
                        extra => bail!("unexpected argument {extra:?}\n{USAGE}"),
                    }
                }
                let device =
                    device.with_context(|| format!("name the device to remove\n{USAGE}"))?;
                Ok(DeviceArgs::Remove { device, keep, yes })
            }
            _ => bail!("{USAGE}"),
        }
    }
}

#[derive(Debug, Deserialize)]
struct DeviceView {
    machine_id: String,
    name: String,
    #[serde(default)]
    this_device: bool,
    #[serde(default)]
    revoked: bool,
}

impl DeviceView {
    fn label(&self) -> String {
        if self.name.is_empty() || self.name == self.machine_id {
            self.machine_id.clone()
        } else {
            format!("{} ({})", self.name, self.machine_id)
        }
    }
}

#[derive(Deserialize)]
struct DeviceList {
    identity: Option<String>,
    devices: Vec<DeviceView>,
}

#[derive(Debug, Deserialize)]
struct RemoveResponse {
    target: DeviceView,
    revoked: Vec<DeviceView>,
    epoch: Option<u32>,
    #[serde(default)]
    access_error: Option<String>,
}

/// The devices besides the target that a removal would take with it and
/// that the user hasn't confirmed, as the refusal to show them.
fn unconfirmed(preview: &RemoveResponse, yes: bool) -> Option<String> {
    let extra: Vec<&DeviceView> = preview
        .revoked
        .iter()
        .filter(|d| d.machine_id != preview.target.machine_id)
        .collect();
    if extra.is_empty() || yes {
        return None;
    }
    let mut message = format!(
        "removing {} also removes the devices it added, directly or through others:\n",
        preview.target.label()
    );
    for device in &extra {
        message.push_str(&format!("  {}\n", device.label()));
    }
    message.push_str(
        "keep the ones you still hold with --keep <name>, or pass --yes to remove them all",
    );
    Some(message)
}

pub(crate) fn cmd_device(args: &[String]) -> Result<()> {
    let client = api::client(Duration::from_secs(60))?;
    let base = api::base_url();
    match DeviceArgs::parse(args)? {
        DeviceArgs::List => {
            let list: DeviceList = api::daemon_ok(
                client
                    .get(format!("{base}/v1/devices"))
                    .send()
                    .context("listing devices on the daemon")?,
            )?
            .json()?;
            let Some(identity) = list.identity else {
                println!("this device holds no sync identity; pair it with `sb pair`");
                return Ok(());
            };
            println!("sync identity {identity}");
            for device in &list.devices {
                let state = match (device.this_device, device.revoked) {
                    (true, true) => "this device, removed",
                    (true, false) => "this device",
                    (false, true) => "removed",
                    (false, false) => "active",
                };
                println!("  {:<40} {state}", device.label());
            }
            Ok(())
        }
        DeviceArgs::Remove { device, keep, yes } => {
            let remove = |dry_run: bool, expected: Option<Vec<&str>>| -> Result<RemoveResponse> {
                Ok(api::daemon_ok(
                    client
                        .post(format!("{base}/v1/devices/remove"))
                        .json(&serde_json::json!({
                            "device": device,
                            "keep": keep,
                            "dry_run": dry_run,
                            "expected": expected,
                        }))
                        .send()
                        .context("calling device removal on the daemon")?,
                )?
                .json()?)
            };
            let preview = remove(true, None)?;
            if let Some(refusal) = unconfirmed(&preview, yes) {
                bail!("{refusal}");
            }
            let shown = preview
                .revoked
                .iter()
                .map(|d| d.machine_id.as_str())
                .collect();
            let done = remove(false, Some(shown))?;
            let names: Vec<String> = done.revoked.iter().map(DeviceView::label).collect();
            println!("removed {}", names.join(", "));
            if let Some(epoch) = done.epoch {
                println!(
                    "minted key epoch {epoch}; the remaining devices receive it at their next sync"
                );
            }
            if let Some(error) = &done.access_error {
                eprintln!(
                    "warning: the daemon could not finish cutting the removed devices' ssh \
                     access, and retries after every sync: {error}"
                );
            }
            Ok(())
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn words(line: &str) -> Vec<String> {
        line.split_whitespace().map(str::to_string).collect()
    }

    #[test]
    fn arguments_parse_into_a_command_or_the_usage() {
        assert_eq!(DeviceArgs::parse(&words("list")).unwrap(), DeviceArgs::List);
        assert_eq!(
            DeviceArgs::parse(&words("remove laptop --keep pi --keep mac --yes")).unwrap(),
            DeviceArgs::Remove {
                device: "laptop".into(),
                keep: vec!["pi".into(), "mac".into()],
                yes: true,
            }
        );
        assert_eq!(
            DeviceArgs::parse(&words("remove --keep pi laptop")).unwrap(),
            DeviceArgs::Remove {
                device: "laptop".into(),
                keep: vec!["pi".into()],
                yes: false,
            }
        );
        for bad in [
            "",
            "list extra",
            "remove",
            "remove a b",
            "remove a --keep",
            "remove a --lost",
            "add a",
        ] {
            let err = format!("{:#}", DeviceArgs::parse(&words(bad)).unwrap_err());
            assert!(err.contains("usage: sb device"), "{bad:?}: {err}");
        }
    }

    fn view(id: &str, name: &str) -> DeviceView {
        DeviceView {
            machine_id: id.into(),
            name: name.into(),
            this_device: false,
            revoked: false,
        }
    }

    #[test]
    fn devices_beyond_the_target_need_keep_or_yes() {
        let alone = RemoveResponse {
            target: view("m1", "laptop"),
            revoked: vec![view("m1", "laptop")],
            epoch: None,
            access_error: None,
        };
        assert_eq!(unconfirmed(&alone, false), None);

        let more = RemoveResponse {
            target: view("m1", "laptop"),
            revoked: vec![view("m1", "laptop"), view("m2", "pi")],
            epoch: None,
            access_error: None,
        };
        assert_eq!(unconfirmed(&more, true), None);
        let refusal = unconfirmed(&more, false).unwrap();
        assert!(refusal.contains("pi (m2)"), "{refusal}");
        assert!(!refusal.contains("  laptop"), "{refusal}");
        assert!(refusal.contains("--keep"), "{refusal}");
    }
}