The command line from another machine: every command through the API (#23, completes #21) 67bfa06a894f

//! The whole command line from a workstation (spec §8.6, spectra#21 and

//! #23): the daemon on one machine, the owner, their agents and every

//! command on another, with no ledger file on the workstation at all.

mod common;

use common::{add_agent, delegate, hermetic, run, text, Serving};

use serde_json::{json, Value};

use spectra_core::keys::KeyPair;

use std::path::Path;

use std::process::Stdio;

use std::time::Duration;

use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};

fn json_of(d: &Path, args: &[&str]) -> Value {

    let o = run(d, args);

    assert!(o.status.success(), "{args:?}: {}", text(&o));

    serde_json::from_slice(&o.stdout)

        .unwrap_or_else(|e| panic!("{args:?}: one JSON document ({e}): {}", String::from_utf8_lossy(&o.stdout)))

}

/// A server in `s`, claimed by the owner whose home is `c/owner`.

fn connected(s: &Path, c: &Path) -> (Serving, u16) {

    KeyPair::create_home(&c.join("owner"), "Andy McCall", "").unwrap();

    let owner = KeyPair::load_home(&c.join("owner")).unwrap();

    assert!(run(s, &["init", "--owner", &owner.key.to_hex(), "--name", "earth"]).status.success());

    let (srv, port) = Serving::start_tls(s);

    let url = format!("https://127.0.0.1:{port}");

    assert_eq!(run(c, &["connect", &url]).status.code(), Some(1));

    delegate(&c.join("owner"), &KeyPair::instance(&s.join("data"), "earth").unwrap());

    let o = run(c, &["connect", &url]);

    assert!(o.status.success(), "{}", text(&o));

    (srv, port)

}

#[tokio::test]

async fn every_command_works_from_another_machine() {

    let (sd, cd) = (tempfile::tempdir().unwrap(), tempfile::tempdir().unwrap());

    let (s, c) = (sd.path(), cd.path());

    let (srv, _port) = connected(s, c);

    std::fs::create_dir_all(c.join("oxygen")).unwrap();

    let o = run(c, &["project", "add", c.join("oxygen").to_str().unwrap()]);

    assert!(o.status.success(), "{}", text(&o));

    add_agent(c, "claude-oxygen", &[]);

    add_agent(c, "spare", &[]);

    let id = json_of(c, &["identity", "show", "--json"]);

    assert_eq!(id["instance"]["name"], "earth");

    assert_eq!(id["instance"]["delegated"], true, "{id}");

    let agents = json_of(c, &["agent", "list", "--json"]);

    let claude = agents.as_array().unwrap().iter().find(|a| a["name"] == "claude-oxygen").unwrap();

    assert_eq!(claude["state"], "ok", "{claude}");

    assert_eq!(claude["display"], "claude-oxygen · Andy McCall's agent");

    let projects = json_of(c, &["project", "list", "--json"]);

    assert_eq!(projects[0]["name"], "oxygen");

    assert!(projects[0]["agents"].as_array().unwrap().contains(&json!("claude-oxygen")));

    let o = run(c, &["agent", "disable", "spare"]);

    assert!(o.status.success(), "{}", text(&o));

    assert_eq!(json_of(c, &["say", "--json", "-c", "general", "the release is tomorrow"])["channel"], "#general");

    assert!(json_of(c, &["inbox", "--json"]).is_array());

    assert_eq!(json_of(c, &["search", "--json", "release"]).as_array().unwrap().len(), 1);

    let brief: Value = serde_json::from_slice(&run(c, &["api", "GET", "/api/v1/brief"]).stdout).unwrap();

    assert_eq!(brief["actor"], "human");

    // An agent's shim on the workstation talks to the server.

    let mut cmd = tokio::process::Command::from(hermetic(c));

    let home = c.join("agents/claude-oxygen");

    cmd.args(["mcp", "--agent", "claude-oxygen", "--home", home.to_str().unwrap()])

        .stdin(Stdio::piped())

        .stdout(Stdio::piped())

        .stderr(Stdio::piped())

        .kill_on_drop(true);

    let mut shim = cmd.spawn().unwrap();

    let mut stdin = shim.stdin.take().unwrap();

    let mut lines = BufReader::new(shim.stdout.take().unwrap()).lines();

    for v in [

        json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2025-06-18", "capabilities": {}, "clientInfo": { "name": "t", "version": "1" } } }),

        json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { "name": "brief", "arguments": {} } }),

    ] {

        stdin.write_all(format!("{v}\n").as_bytes()).await.unwrap();

    }

    stdin.flush().await.unwrap();

    let mut brief = Value::Null;

    for _ in 0..2 {

        let line = tokio::time::timeout(Duration::from_secs(20), lines.next_line()).await.unwrap().unwrap().unwrap();

        let v: Value = serde_json::from_str(&line).unwrap();

        if v["id"] == 2 {

            brief = v;

        }

    }

    assert!(brief["result"]["content"][0]["text"].as_str().unwrap().contains("You are claude-oxygen · Andy McCall's agent"), "{brief}");

    drop(shim);

    // The ledger stays on the server: verify asks it; check and rebuild refuse here.

    let v = json_of(c, &["admin", "verify", "--json"]);

    assert!(v["findings"].as_array().unwrap().is_empty(), "{v}");

    let o = run(c, &["admin", "check"]);

    assert!(!o.status.success() && text(&o).contains("runs on the server"), "{}", text(&o));

    assert!(!c.join("data").exists(), "the workstation has no data directory");

    srv.stop();

    let o = run(s, &["admin", "verify"]);

    assert!(o.status.success(), "{}", text(&o));

}

- **Changed: the command line works from another machine (#23).** With a server configured by `spectra connect`, every command goes through the JSON API and the workstation needs no ledger file: `identity show`, `agent add`, `list` and `disable`, `project add` and `list`, `say`, `inbox`, `search`, `api` and `admin verify`, which the server runs on its own ledger (`GET /api/v1/admin/verify`). `admin check` and `rebuild` say they run on the server. Locally, commands read through the daemon whenever it is serving, so the same path is exercised on one machine and on two. The API's agents now carry their delegation state and expiry, projects their agents, and inbox items and search hits their author's display name.

    /// `ok` while the owner's identity delegates to the key, else why not.

    #[serde(default)]

    pub state: String,

    /// When the owner's delegation to the key ends, in ms.

    #[serde(default)]

    pub delegation_expires: Option<u64>,

    /// Its agents that are not disabled.

    #[serde(default)]

    pub agents: Vec<String>,

    /// `claude-oxygen · Andy McCall's agent`, or the human's name.

    #[serde(default)]

    pub from_display: String,

    #[serde(default)]

    pub author_display: String,

  delegation_expires?: number | null;

  state?: string;

  agents?: string[];

  from_display?: string;

  author_display?: string;

        .route("/api/v1/admin/verify", get(admin_verify))

/// `GET /api/v1/admin/verify`: the owner asks the daemon to verify its

/// ledger (spec §8.6): what `spectra admin verify` prints, from afar.

async fn admin_verify(

    State(st): State<AppState>,

    ConnectInfo(peer): ConnectInfo<PeerInfo>,

    headers: HeaderMap,

    uri: axum::http::Uri,

) -> Response {

    let c = who!(st, peer, headers, uri, "GET", b"", false);

    if !matches!(c.principal, Principal::Owner { .. }) {

        return problem(StatusCode::FORBIDDEN, "only the owner verifies the ledger", None);

    }

    let ledger = match spectra_core::ledger::Ledger::open_read_only(&st.daemon.data.join("spectra.db")).await {

        Ok(l) => l,

        Err(e) => return bad(e),

    };

    match ledger.verify(&mut spectra_core::principals::Principals::default()).await {

        Ok(v) => axum::Json(v).into_response(),

        Err(e) => bad(e),

    }

}

    let principals = st.daemon.principals.read().await;

        .map(|(name, owner, key, kind, project, status, disabled)| {

            let k = oxy_core::hash::ObjectRef::from_hex(&key);

            let state = match k.map(|k| principals.principal(&k, now)) {

                Some(Ok(_)) => "ok".to_string(),

                Some(Err(why)) => why,

                None => "a malformed key".into(),

            };

            let delegation_expires = k.and_then(|k| principals.owner().and_then(|o| o.delegate(&k)).and_then(|d| d.expires));

            api::Agent {

                display: format!("{name} · {owner}'s agent"),

                presence: if disabled.is_some() { "offline".into() } else { presence.state(&name, now).into() },

                disabled: disabled.is_some(),

                name,

                owner,

                key,

                kind,

                project,

                status,

                state,

                delegation_expires,

            }

        let agents = sqlx::query_scalar("SELECT name FROM agents WHERE project = ? AND disabled_ms IS NULL ORDER BY name")

            .bind(&name)

            .fetch_all(pool)

            .await

            .unwrap_or_default();

        out.push(api::Project { name, path, remote, depends_on, depended_on_by, agents });

    let mut out = Vec::new();

    for i in conv::inbox(&st.daemon.ledger, actor, None).await.unwrap_or_default() {

        let from_display = conv::display_name(&st.daemon.ledger, &i.from).await;

        out.push(api::InboxItem {

            id: i.id,

            kind: i.kind,

            at_ms: i.at_ms,

            from: i.from,

            from_display,

            channel: i.channel,

            summary: i.summary,

        });

    }

    out

            let mut out: Vec<api::Hit> = Vec::new();

            for h in hits {

                let author_display = conv::display_name(&st.daemon.ledger, &h.author).await;

                out.push(api::Hit {

                    id: h.id,

                    channel: h.channel,

                    author: h.author,

                    at_ms: h.at_ms,

                    snippet: h.snippet,

                    thread: h.thread,

                    author_display,

                });

            }

- [x] #21 spectra connect — done 2026-11-03: trust through the owner's delegation to the instance key, pin, claim with the rotation delegating causes; tests/connect.rs, and the shim over TLS in tests/client.rs.

- [x] #23 The CLI without a ledger file — done 2026-11-03: every command through the API when a daemon serves, local or remote; admin verify via the server; tests/client.rs runs them all from a workstation with no data directory.

use anyhow::{Context, Result};

    // On a client the server verifies its own ledger (spec §8.6).

    let v: serde_json::Value = match ctx.remote()? {

        Some(_) => {

            let home = super::identity::owner_home(ctx, None);

            let c = ctx.owner_client(&home).await?.context("no server")?;

            super::call(&c, "GET", "/api/v1/admin/verify", None).await?

        }

        None => serde_json::to_value(Ledger::open_read_only(&ctx.db()?).await?.verify(&mut Principals::default()).await?)?,

    };

    let findings = v["findings"].as_array().cloned().unwrap_or_default();

    let clean = findings.is_empty();

        println!("{v}");

        return Ok(if clean { 0 } else { 1 });

    if clean {

            ui::err(format!("{} finding(s)", findings.len()))

    println!("{}", ui::kv("events", v["events"].as_u64().unwrap_or(0)));

    let last = v["last_checkpoint"].as_u64().map(|s| format!("last at #{s}")).unwrap_or_else(|| "none yet".into());

    println!("{}", ui::kv("signed", format!("{} checkpoint(s){}{last}", v["checkpoints"].as_u64().unwrap_or(0), ui::sep())));

    let uncovered = v["uncovered"].as_u64().unwrap_or(0);

    if uncovered > 0 {

        println!("{}", ui::kv("pending", ui::dim(format!("{uncovered} event(s) since, chained and awaiting the next checkpoint"))));

    println!("{}", ui::kv("head", ui::hash(v["head"].as_str().unwrap_or(""))));

    for f in &findings {

        // As the problem is named in code: hash_mismatch is HashMismatch.

        let problem = match &f["problem"] {

            serde_json::Value::String(p) => p

                .split('_')

                .map(|w| {

                    let mut c = w.chars();

                    c.next().map(|f| f.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()

                })

                .collect(),

            other => other.to_string(),

        };

        println!(

            "  {} {} {}",

            ui::id(format!("#{}", f["seq"].as_u64().unwrap_or(0))),

            ui::err(problem),

            f["detail"].as_str().unwrap_or("")

        );

    Ok(if clean { 0 } else { 1 })

    ctx.local_only("spectra admin check")?;

    ctx.local_only("spectra admin rebuild")?;

use super::identity::owner_home;

use super::{call, marks, ui, Ctx};

    let home = owner_home(ctx, a.owner_home.clone());

    let (exists, known) = match ctx.owner_client(&home).await? {

        Some(c) => {

            let agents = call(&c, "GET", "/api/v1/agents", None).await?;

            let projects = call(&c, "GET", "/api/v1/projects", None).await?;

            let has = |v: &serde_json::Value, n: &str| v.as_array().is_some_and(|l| l.iter().any(|x| x["name"] == n));

            (has(&agents, &a.name), has(&projects, &a.project))

        None => {

            let ledger = Ledger::open_read_only(&ctx.db()?).await?;

            let p = Principals::load(&ledger).await?;

            let known: Option<String> =

                sqlx::query_scalar("SELECT name FROM projects WHERE name = ?").bind(&a.project).fetch_optional(ledger.pool()).await?;

            (p.agent_key(&a.name).is_some(), known.is_some())

    };

    if exists {

        bail!("an agent named {} already exists (spectra agent list)", a.name);

    }

    if !known {

        bail!("no project named {} (spectra project add PATH --name {})", a.project, a.project);

    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();

    let out = match ctx.owner_client(&owner_home(ctx, None)).await? {

        Some(c) => call(&c, "GET", "/api/v1/agents", None).await?.as_array().cloned().unwrap_or_default(),

        None => list_local(ctx).await?,

    };

    print_list(out, json)

}

async fn list_local(ctx: &Ctx) -> Result<Vec<serde_json::Value>> {

    Ok(out)

}

fn print_list(out: Vec<serde_json::Value>, json: bool) -> Result<i32> {

    let known = match (w.ledger(), w.client()) {

        (_, Some(c)) => call(c, "GET", "/api/v1/agents", None).await?.as_array().is_some_and(|l| l.iter().any(|x| x["name"] == name)),

        (Some(l), None) => Principals::load(l).await?.agent_key(name).is_some(),

        (None, None) => false,

    };

    if !known {

        bail!("no agent named {name}");

    }

    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();

use super::identity::owner_home;

    ctx.owner_client(home).await

    super::call(c, method, path, body).await

use super::encode;

/// The owner's unread items: from the daemon when one serves, else the ledger.

async fn inbox_items(ctx: &Ctx, client: Option<&Client>) -> Result<Vec<Value>> {

    if let Some(c) = client {

        return Ok(api(c, "GET", "/api/v1/inbox", None).await?.as_array().cloned().unwrap_or_default());

    }

    let mut items = Vec::new();

    Ok(items)

}

pub async fn inbox(ctx: &Ctx, follow: bool, owner_home_flag: Option<PathBuf>, as_json: bool) -> Result<i32> {

    let home = owner_home(ctx, owner_home_flag);

    let client = owner_client(ctx, &home).await?;

    let items = inbox_items(ctx, client.as_ref()).await?;

    let client = client.context("--follow needs `spectra serve` running")?;

    let stream_client = owner_client(ctx, &home).await?.context("--follow needs `spectra serve` running")?;

        stream_client

        for v in inbox_items(ctx, Some(&client)).await? {

            if seen.insert(v["id"].as_str().unwrap_or("").to_string()) {

    let hits: Vec<Value> = match owner_client(ctx, &owner_home(ctx, None)).await? {

        Some(c) => {

            let mut q = format!("/api/v1/search?q={}&limit={limit}", encode(query));

            for (k, v) in [("channel", &channel), ("author", &author), ("since", &since)] {

                if let Some(v) = v {

                    q.push_str(&format!("&{k}={}", encode(v)));

                }

            }

            api(&c, "GET", &q, None).await?.as_array().cloned().unwrap_or_default()

        }

        None => {

            let ledger = Ledger::open_read_only(&ctx.db()?).await?;

            let owner = Principals::load(&ledger).await?;

            let me = owner.owner().context("no owner is recorded")?;

            let principal = spectra_core::principals::Principal::Owner { key: me.hash(), name: me.name.clone() };

            let since = since.as_deref().and_then(|s| spectra_mcp::tools::parse_since(s, spectra_core::ids::now_ms()));

            let mut out = Vec::new();

            for h in conv::search(&ledger, &principal, query, channel.as_deref(), author.as_deref(), since, limit).await? {

                let mut v = serde_json::to_value(&h)?;

                v["author_display"] = conv::display_name(&ledger, &h.author).await.into();

                out.push(v);

            }

            out

        }

    };

        println!("{}", Value::Array(hits));

        let id = h["id"].as_str().unwrap_or("");

            ui::id(&id[..12.min(id.len())]),

            ui::author(h["author_display"].as_str().or(h["author"].as_str()).unwrap_or("")),

            h["channel"].as_str().unwrap_or(""),

            ui::dim(ui::ago(h["at_ms"].as_u64().unwrap_or(0)))

        println!("  {}", h["snippet"].as_str().unwrap_or(""));

    let c = owner_client(ctx, &home).await?.context("`spectra api` needs `spectra serve` running, or `spectra connect`")?;

    if let Some(cfg) = ctx.remote()? {

        return show_remote(&cfg, json).await;

    }

    let rotated = w.refresh_event(&home).await?;

}

/// `identity show` for a Spectra on another machine: what it says of itself.

async fn show_remote(cfg: &super::connect::ClientCfg, json: bool) -> Result<i32> {

    let info = super::call(&spectra_mcp::client::Client::at(cfg.endpoint()?, None), "GET", "/api/v1/instance", None).await?;

    let owner_key = info["owner"].as_str().unwrap_or("").to_string();

    let instance_key = info["instance"]["key"].as_str().unwrap_or("").to_string();

    let home = oxy_core::repo::default_home();

    let me = KeyPair::load_home(&home).ok();

    let delegated = me.as_ref().is_some_and(|m| {

        oxy_core::hash::ObjectRef::from_hex(&instance_key)

            .is_some_and(|k| m.identity.delegates_to(&k, spectra_core::principals::DELEGATION_SCOPE, spectra_core::ids::now_ms()))

    });

    if json {

        println!(

            "{}",

            serde_json::json!({

                "server": cfg.server,

                "owner": { "name": me.as_ref().map(|m| m.identity.name.clone()), "key": owner_key },

                "instance": { "name": info["name"], "key": instance_key, "delegated": delegated },

            })

        );

        return Ok(0);

    }

    println!("{}", ui::section("Server"));

    println!("{}", ui::kv("url", ui::path(&cfg.server)));

    println!("{}", ui::section("Owner"));

    if let Some(m) = &me {

        println!("{}", ui::kv("name", ui::author(format!("{} <{}>", m.identity.name, m.identity.email))));

    }

    println!("{}", ui::kv("key", ui::hash(&owner_key)));

    println!("{}", ui::section("Instance"));

    println!("{}", ui::kv("name", info["name"].as_str().unwrap_or("")));

    println!("{}", ui::kv("key", ui::hash(&instance_key)));

    if delegated {

        println!("{}", ui::kv("status", ui::ok("delegated by you: its checkpoints and certificate are verifiably yours")));

    } else {

        println!("{}", ui::kv("status", ui::warn("not delegated by your current identity")));

    }

    Ok(0)

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

    /// A client signing as the owner: to the configured server (spec §8.6),

    /// or to the local daemon when it is serving; none when neither. It

    /// signs with the owner identity the ledger records, since the daemon

    /// may not know a newer one yet.

    pub async fn owner_client(&self, owner_home: &std::path::Path) -> Result<Option<spectra_mcp::client::Client>> {

        use spectra_mcp::client::Client;

        if let Some(cfg) = self.remote()? {

            let ep = cfg.endpoint()?;

            let pair = remote_owner(&ep, owner_home).await?;

            return Ok(Some(Client::at(ep, Some(pair))));

        }

        if !self.data.join("spectra.db").exists() || !Client::alive(&self.socket()).await {

            return Ok(None);

        }

        let ledger = spectra_core::ledger::Ledger::open_read_only(&self.db()?).await?;

        Ok(Some(Client::new(&self.socket(), Some(identity::recorded_owner(&ledger, owner_home).await?))))

    }

    /// Somewhere to append the owner's signed events: the configured server,

    /// the local daemon when it is serving, else straight to the ledger

    /// (spec §8.5, §8.6).

        if let Some(cfg) = self.remote()? {

            let ep = cfg.endpoint()?;

            let pair = remote_owner(&ep, owner_home).await?;

            let recorded = pair.identity.clone();

            return Ok(Writer::Remote { client: Box::new(spectra_mcp::client::Client::at(ep, Some(pair))), recorded });

        }

    }

    /// Refuse a command that needs the ledger file on this machine.

    pub fn local_only(&self, what: &str) -> Result<()> {

        if self.remote()?.is_some() {

            bail!("{what} runs on the server, which holds the ledger (this machine uses {})", connect::path().display());

        }

        Ok(())

    Daemon {

        ledger: spectra_core::ledger::Ledger,

        client: Box<spectra_mcp::client::Client>,

    },

    /// A Spectra on another machine; `recorded` is the owner identity it knows.

    Remote {

        client: Box<spectra_mcp::client::Client>,

        recorded: oxy_core::identity::Identity,

    },

    /// The ledger on this machine, for reading, if there is one.

    pub fn ledger(&self) -> Option<&spectra_core::ledger::Ledger> {

            Writer::Direct(l) | Writer::Daemon { ledger: l, .. } => Some(l),

            Writer::Remote { .. } => None,

    /// A client of the daemon, when one is serving.

    pub fn client(&self) -> Option<&spectra_mcp::client::Client> {

        match self {

            Writer::Daemon { client, .. } | Writer::Remote { client, .. } => Some(client),

            Writer::Direct(_) => None,

        }

    }

    /// The rotation that brings the recorded owner to the current identity

    /// in `home`, if it has moved.

    pub async fn refresh_event(&self, home: &std::path::Path) -> Result<Option<spectra_core::event::NewEvent>> {

        match self {

            Writer::Direct(l) | Writer::Daemon { ledger: l, .. } => identity::refresh_event(l, home).await,

            Writer::Remote { recorded, .. } => identity::rotation(recorded, home),

        }

    }

            Writer::Daemon { client, .. } | Writer::Remote { client, .. } => {

}

/// The owner identity a server records, as a key pair from the owner's

/// home: what requests to it are signed with.

async fn remote_owner(ep: &spectra_mcp::client::Endpoint, home: &std::path::Path) -> Result<spectra_core::keys::KeyPair> {

    let r = spectra_mcp::client::Client::at(ep.clone(), None).send("GET", "/api/v1/instance", &[], vec![]).await?;

    let info = r.json()?;

    let key = info.get("owner").and_then(|o| o.as_str()).context("the server has no owner yet: spectra connect claims it")?;

    let keys = home.join("keys");

    spectra_core::keys::KeyPair::load(&keys.join(format!("{key}.secret")), &keys.join(format!("{key}.identity")))

        .with_context(|| format!("the server's owner {} is not an identity in {}", &key[..12.min(key.len())], home.display()))

}

/// An API call; a refusal becomes an error that says why.

pub async fn call(c: &spectra_mcp::client::Client, method: &str, path: &str, body: Option<serde_json::Value>) -> Result<serde_json::Value> {

    let r = c.send(method, path, &[], body.map(|b| serde_json::to_vec(&b)).transpose()?.unwrap_or_default()).await?;

    let v: serde_json::Value = r.json().unwrap_or(serde_json::Value::Null);

    if r.status >= 400 {

        let why = v

            .get("detail")

            .or(v.get("title"))

            .and_then(serde_json::Value::as_str)

            .map(String::from)

            .unwrap_or_else(|| String::from_utf8_lossy(&r.body).into());

        bail!("{why}");

    }

    Ok(v)

}

/// A query string value, percent-encoded.

pub fn encode(s: &str) -> String {

    s.bytes()

        .map(|b| match b {

            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => (b as char).to_string(),

            _ => format!("%{b:02X}"),

        })

        .collect()

use super::identity::owner_home;

use super::{call, ui, Ctx};

    let path_s = path.display().to_string();

    let existing = all(&w).await?;

    if let Some(e) = existing.iter().find(|p| p["name"] == name.as_str() || p["path"] == path_s.as_str()) {

        bail!("{} is already a project ({})", path.display(), e["name"].as_str().unwrap_or(""));

    let mut events: Vec<_> = w.refresh_event(&home).await?.into_iter().collect();

    let now = all(&w).await?;

    let me = now.iter().find(|p| p["name"] == name.as_str()).cloned().unwrap_or_default();

    let names =

        |k: &str| me[k].as_array().map(|a| a.iter().filter_map(|v| v.as_str().map(String::from)).collect::<Vec<_>>()).unwrap_or_default();

    let (deps, users) = (names("depends_on"), names("depended_on_by"));

/// Every project with its relations and agents: from the daemon when one

/// serves, else from the ledger here.

async fn all(w: &super::Writer) -> Result<Vec<serde_json::Value>> {

    match (w.client(), w.ledger()) {

        (Some(c), _) => Ok(call(c, "GET", "/api/v1/projects", None).await?.as_array().cloned().unwrap_or_default()),

        (None, Some(l)) => local(l).await,

        (None, None) => Ok(vec![]),

    }

}

async fn local(ledger: &Ledger) -> Result<Vec<serde_json::Value>> {

        let (deps, users) = relations(ledger, &name).await?;

    Ok(out)

}

pub async fn list(ctx: &Ctx, json: bool) -> Result<i32> {

    let out = match ctx.owner_client(&owner_home(ctx, None)).await? {

        Some(c) => call(&c, "GET", "/api/v1/projects", None).await?.as_array().cloned().unwrap_or_default(),

        None => local(&Ledger::open_read_only(&ctx.db()?).await?).await?,

    };