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,
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 {
device: String,
#[serde(default)]
keep: Vec<String>,
#[serde(default)]
dry_run: bool,
#[serde(default)]
expected: Option<Vec<String>>,
}
#[derive(Serialize)]
struct RemoveResponse {
target: DeviceView,
revoked: Vec<DeviceView>,
#[serde(skip_serializing_if = "Option::is_none")]
epoch: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
access_error: Option<String>,
}
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),
}
}