second-brain-api 0.13.5

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
use std::collections::BTreeSet;
use std::sync::Arc;

use axum::Json;
use axum::extract::State;
use axum::response::{IntoResponse, Response};
use second_brain_core::keys::StoredDeviceRecord;
use second_brain_sync::keyring::{Keyring, RemovalRefused};
use serde::{Deserialize, Serialize};

use super::{bad_request, internal_error};
use crate::{AppState, identity_report};

#[derive(Serialize)]
struct DeviceView {
    machine_id: String,
    name: String,
    this_device: bool,
    revoked: bool,
    /// The devices that signed its first row, other than itself.
    added_by: Vec<String>,
}

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

fn members(state: &AppState) -> anyhow::Result<(Option<String>, Vec<StoredDeviceRecord>)> {
    let keyring = Keyring::load(&state.sqlite, &state.data_dir)?;
    let Some(tag) = keyring.identity() else {
        return Ok((None, Vec::new()));
    };
    let rows = state
        .sqlite
        .device_records()?
        .into_iter()
        .filter(|row| row.current.record.identity_tag == tag.as_str())
        .collect();
    Ok((Some(tag.as_str().to_string()), rows))
}

fn view(state: &AppState, row: &StoredDeviceRecord) -> DeviceView {
    let id = &row.current.record.machine_id;
    DeviceView {
        machine_id: id.clone(),
        name: row.current.record.name.clone(),
        this_device: id == state.sqlite.machine_id(),
        revoked: row.revoked,
        added_by: row
            .first
            .signatures
            .iter()
            .map(|s| s.signer.clone())
            .filter(|signer| signer != id)
            .collect(),
    }
}

pub(super) async fn list_devices(State(state): State<Arc<AppState>>) -> Response {
    let result = tokio::task::spawn_blocking(move || -> anyhow::Result<DeviceList> {
        let (identity, rows) = members(&state)?;
        Ok(DeviceList {
            identity,
            devices: rows.iter().map(|row| view(&state, row)).collect(),
        })
    })
    .await;
    match result {
        Ok(Ok(list)) => Json(list).into_response(),
        Ok(Err(e)) => internal_error(e),
        Err(e) => internal_error(e),
    }
}

#[derive(Deserialize)]
pub(super) struct RemoveRequest {
    /// A device name or machine id.
    device: String,
    #[serde(default)]
    keep: Vec<String>,
    #[serde(default)]
    dry_run: bool,
    /// The machine ids a preview showed; the removal is refused when it
    /// would now reach others.
    #[serde(default)]
    expected: Option<Vec<String>>,
}

#[derive(Serialize)]
struct RemoveResponse {
    target: DeviceView,
    revoked: Vec<DeviceView>,
    /// The epoch minted for the remaining devices; absent on a dry run.
    #[serde(skip_serializing_if = "Option::is_none")]
    epoch: Option<u32>,
    /// Why the removed devices' ssh lines could not be cut, if they could
    /// not; the next handshake retries.
    #[serde(skip_serializing_if = "Option::is_none")]
    access_error: Option<String>,
}

/// Resolves a name or machine id to one device of this identity.
fn resolve<'a>(
    rows: &'a [StoredDeviceRecord],
    given: &str,
) -> Result<&'a StoredDeviceRecord, String> {
    if let Some(row) = rows.iter().find(|r| r.current.record.machine_id == given) {
        return Ok(row);
    }
    let named: Vec<&StoredDeviceRecord> = rows
        .iter()
        .filter(|r| r.current.record.name == given)
        .collect();
    let active: Vec<&StoredDeviceRecord> = named.iter().copied().filter(|r| !r.revoked).collect();
    let named = if active.is_empty() { named } else { active };
    match named[..] {
        [row] => Ok(row),
        [] => Err(format!(
            "no device named {given} belongs to this sync identity; `sb device list` shows them"
        )),
        _ => Err(format!(
            "more than one device is named {given}; give its machine id instead: {}",
            named
                .iter()
                .map(|r| r.current.record.machine_id.as_str())
                .collect::<Vec<_>>()
                .join(", ")
        )),
    }
}

fn remove(state: &AppState, req: &RemoveRequest) -> anyhow::Result<Result<RemoveResponse, String>> {
    let (_, rows) = members(state)?;
    let target = match resolve(&rows, &req.device) {
        Ok(row) => row.current.record.machine_id.clone(),
        Err(message) => return Ok(Err(message)),
    };
    let mut keep = BTreeSet::new();
    for given in &req.keep {
        match resolve(&rows, given) {
            Ok(row) => keep.insert(row.current.record.machine_id.clone()),
            Err(message) => return Ok(Err(message)),
        };
    }
    let keyring = Keyring::load(&state.sqlite, &state.data_dir)?;
    let removal = match (&req.expected, req.dry_run) {
        (_, true) => keyring.removal_preview(&target, &keep),
        (Some(expected), false) => match keyring.removal_preview(&target, &keep) {
            Ok(preview) if preview.revoked != *expected => {
                return Ok(Err(format!(
                    "this removal now reaches {} instead of what was shown; run it again",
                    preview.revoked.join(", ")
                )));
            }
            Ok(_) => keyring.remove_device(&target, &keep, state.clock.wall_micros()),
            Err(e) => Err(e),
        },
        (None, false) => keyring.remove_device(&target, &keep, state.clock.wall_micros()),
    };
    let removal = match removal {
        Ok(removal) => removal,
        Err(e) => match e.downcast_ref::<RemovalRefused>() {
            Some(refused) => return Ok(Err(refused.to_string())),
            None => return Err(e),
        },
    };
    let access_error = (!req.dry_run)
        .then(|| {
            state
                .device_access
                .reconcile(&state.sqlite, &state.data_dir)
                .err()
                .map(|e| format!("{e:#}"))
        })
        .flatten();
    if !req.dry_run {
        identity_report::report(&state.sqlite, &state.data_dir, &state.health);
    }
    let rows = if req.dry_run { rows } else { members(state)?.1 };
    let view_of = |id: &str| match rows.iter().find(|r| r.current.record.machine_id == id) {
        Some(row) => view(state, row),
        None => DeviceView {
            machine_id: id.to_string(),
            name: String::new(),
            this_device: false,
            revoked: !req.dry_run,
            added_by: Vec::new(),
        },
    };
    Ok(Ok(RemoveResponse {
        target: view_of(&removal.target),
        revoked: removal.revoked.iter().map(|id| view_of(id)).collect(),
        epoch: removal.epoch.map(|e| e.number),
        access_error,
    }))
}

pub(super) async fn remove_device(
    State(state): State<Arc<AppState>>,
    Json(req): Json<RemoveRequest>,
) -> Response {
    let result = tokio::task::spawn_blocking(move || remove(&state, &req)).await;
    match result {
        Ok(Ok(Ok(response))) => Json(response).into_response(),
        Ok(Ok(Err(message))) => bad_request(message),
        Ok(Err(e)) => internal_error(e),
        Err(e) => internal_error(e),
    }
}