mod.rs 61.3%

49 of 80 lines run, 9 of 26 functions · run #6 on main · run missed

//! The `spectra` command line (spec §19). Output follows `oxy`: colour and
//! glyphs on a UTF-8 terminal, plain when piped, with `--plain` or with
//! `NO_COLOR`; `--json` prints one document on stdout and nothing else.

pub mod admin;
pub mod agent;
pub mod format;
pub mod identity;
pub mod json;
pub mod marks;
pub mod project;
pub mod ui;

use anyhow::{bail, Result};
use clap::{Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "spectra", version = env!("SPECTRA_VERSION_LONG"), about = "A control plane for AI coding agents")]
pub struct Cli {
    /// Plain output: no colour or glyphs (also NO_COLOR, or when not a terminal)
    #[arg(long, global = true)]
    pub plain: bool,
    /// The data directory (default: $XDG_DATA_HOME/spectra, else ~/.local/share/spectra)
    #[arg(long, global = true, env = "SPECTRA_DATA")]
    pub data: Option<PathBuf>,
    #[command(subcommand)]
    pub command: Command,
}

#[derive(Subcommand)]
pub enum Command {
    /// The version and build of this binary
    Version {
        /// Machine-readable output
        #[arg(long)]
        json: bool,
    },
    /// Make this machine's Spectra: record the owner's identity (read from
    /// their OXY_HOME and proven by signing) and make the instance key
    Init {
        /// The owner's OXY_HOME (default: $OXY_HOME, else ~/.config/oxy)
        #[arg(long)]
        owner_home: Option<PathBuf>,
        /// This instance's name (default: the host name)
        #[arg(long)]
        name: Option<String>,
    },
    /// The owner's and the instance's identities: show, refresh
    Identity {
        #[command(subcommand)]
        command: IdentityCmd,
    },
    /// The checkouts agents work in: add, list
    Project {
        #[command(subcommand)]
        command: ProjectCmd,
    },
    /// Agents, each its owner's delegate: add, list, disable
    Agent {
        #[command(subcommand)]
        command: AgentCmd,
    },
    /// The ledger's own checks: verify, check, rebuild
    Admin {
        #[command(subcommand)]
        command: Admin,
    },
}

#[derive(Subcommand)]
pub enum IdentityCmd {
    /// The owner and the instance as the ledger knows them
    Show {
        #[arg(long)]
        json: bool,
    },
    /// Record the owner's current identity after `oxy identity delegate add|remove`
    Refresh {
        #[arg(long)]
        owner_home: Option<PathBuf>,
    },
}

#[derive(Subcommand)]
pub enum ProjectCmd {
    /// Register a checkout: its repository id, remote and pinned subrepos
    Add {
        path: PathBuf,
        /// Its name (default: the directory's)
        #[arg(long)]
        name: Option<String>,
        /// Its remote URL (default: the checkout's origin)
        #[arg(long)]
        remote: Option<String>,
        #[arg(long)]
        owner_home: Option<PathBuf>,
    },
    /// Every project with what it pins, what pins it, and its agents
    List {
        #[arg(long)]
        json: bool,
    },
}

#[derive(Subcommand)]
pub enum AgentCmd {
    /// Make an agent's key in its own home and record it once you delegate to it
    Add {
        /// Lower-case letters, digits and dashes
        name: String,
        /// claude-code, antigravity, kimi-code, codex or other
        #[arg(long)]
        kind: String,
        /// The project it works in
        #[arg(long)]
        project: String,
        /// The agent's own OXY_HOME, where its key is made and kept
        #[arg(long)]
        home: PathBuf,
        /// Bind the key to this Unix user: a request from another is refused
        #[arg(long)]
        uid: Option<u32>,
        /// Bind the key to the Unix user of its first signed connection
        #[arg(long, conflicts_with = "uid")]
        learn_uid: bool,
        /// How long to wait for your delegation, in seconds
        #[arg(long, default_value_t = 600)]
        wait: u64,
        /// The owner's OXY_HOME
        #[arg(long)]
        owner_home: Option<PathBuf>,
    },
    /// Every agent with its owner, key, delegation and state
    List {
        #[arg(long)]
        json: bool,
    },
    /// Refuse an agent's key from now on
    Disable {
        name: String,
        #[arg(long)]
        owner_home: Option<PathBuf>,
    },
}

#[derive(Subcommand)]
pub enum Admin {
    /// Recompute the hash chain and check every checkpoint and proof (exit 1 on any finding)
    Verify {
        /// Machine-readable output
        #[arg(long)]
        json: bool,
    },
    /// Whether the projections equal a rebuild from the ledger
    Check,
    /// Replay the ledger into every projection
    Rebuild,
}

/// What every command needs: where the data lives.
pub struct Ctx {
    pub data: PathBuf,
}

impl Ctx {
    /// The ledger's database, which must exist.
    pub fn db(&self) -> Result<PathBuf> {
        let db = self.data.join("spectra.db");
        if !db.exists() {
            bail!("no Spectra in {} (run `spectra init`, or pass --data)", self.data.display());
        }
        Ok(db)
    }

    /// The ledger, for writing: the instance key signs its checkpoints, and
    /// the lock keeps any other writer out.
    pub async fn writer(&self) -> Result<spectra_core::ledger::Ledger> {
        let db = self.db()?;
        let instance = spectra_core::keys::KeyPair::instance(&self.data, "spectra")?;
        spectra_core::ledger::Ledger::open(&db, Some(instance)).await
    }

    /// `[owner] home` from spectra.toml.
    pub fn config_owner_home(&self) -> Option<PathBuf> {
        let text = std::fs::read_to_string(self.data.join("spectra.toml")).ok()?;
        let t: toml::Table = text.parse().ok()?;
        t.get("owner")?.get("home")?.as_str().map(PathBuf::from)
    }
}

fn default_data() -> PathBuf {
    if let Ok(x) = std::env::var("XDG_DATA_HOME") {
        return PathBuf::from(x).join("spectra");
    }
    let home = std::env::var("HOME").unwrap_or_else(|_| ".".into());
    PathBuf::from(home).join(".local").join("share").join("spectra")
}

fn runtime() -> Result<tokio::runtime::Runtime> {
    Ok(tokio::runtime::Builder::new_multi_thread().enable_all().build()?)
}

pub fn run() -> Result<i32> {
    let cli = Cli::parse();
    ui::init(cli.plain);
    let ctx = Ctx { data: cli.data.unwrap_or_else(default_data) };
    match cli.command {
        Command::Version { json } => version(json),
        Command::Init { owner_home, name } => runtime()?.block_on(identity::init(&ctx, owner_home, name)),
        Command::Identity { command } => runtime()?.block_on(async {
            match command {
                IdentityCmd::Show { json } => identity::show(&ctx, json).await,
                IdentityCmd::Refresh { owner_home } => identity::refresh(&ctx, owner_home).await,
            }
        }),
        Command::Project { command } => runtime()?.block_on(async {
            match command {
                ProjectCmd::Add { path, name, remote, owner_home } => project::add(&ctx, &path, name, remote, owner_home).await,
                ProjectCmd::List { json } => project::list(&ctx, json).await,
            }
        }),
        Command::Agent { command } => runtime()?.block_on(async {
            match command {
                AgentCmd::Add { name, kind, project, home, uid, learn_uid, wait, owner_home } => {
                    agent::add(&ctx, agent::Add { name, kind, project, home, uid, learn_uid, wait_secs: wait, owner_home }).await
                }
                AgentCmd::List { json } => agent::list(&ctx, json).await,
                AgentCmd::Disable { name, owner_home } => agent::disable(&ctx, &name, owner_home).await,
            }
        }),
        Command::Admin { command } => runtime()?.block_on(async {
            match command {
                Admin::Verify { json } => admin::verify(&ctx, json).await,
                Admin::Check => admin::check(&ctx).await,
                Admin::Rebuild => admin::rebuild(&ctx).await,
            }
        }),
    }
}

fn version(as_json: bool) -> Result<i32> {
    if as_json {
        println!(
            "{}",
            serde_json::json!({
                "version": env!("CARGO_PKG_VERSION"),
                "build": env!("SPECTRA_BUILD_ID"),
                "mcp_protocol_versions": spectra_mcp::PROTOCOL_VERSIONS,
                "ledger_format": spectra_core::LEDGER_FORMAT,
            })
        );
    } else {
        println!("spectra {}", env!("SPECTRA_VERSION_LONG"));
    }
    Ok(0)
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! The `spectra` command line (spec §19). Output follows `oxy`: colour and
2		//! glyphs on a UTF-8 terminal, plain when piped, with `--plain` or with
3		//! `NO_COLOR`; `--json` prints one document on stdout and nothing else.
4
5		pub mod admin;
6		pub mod agent;
7		pub mod format;
8		pub mod identity;
9		pub mod json;
10		pub mod marks;
11		pub mod project;
12		pub mod ui;
13
14		use anyhow::{bail, Result};
15		use clap::{Parser, Subcommand};
16		use std::path::PathBuf;
17
18		#[derive(Parser)]
19		#[command(name = "spectra", version = env!("SPECTRA_VERSION_LONG"), about = "A control plane for AI coding agents")]
20		pub struct Cli {
21		/// Plain output: no colour or glyphs (also NO_COLOR, or when not a terminal)
22		#[arg(long, global = true)]
23		pub plain: bool,
24		/// The data directory (default: $XDG_DATA_HOME/spectra, else ~/.local/share/spectra)
25		#[arg(long, global = true, env = "SPECTRA_DATA")]
26		pub data: Option<PathBuf>,
27		#[command(subcommand)]
28		pub command: Command,
29		}
30
31		#[derive(Subcommand)]
32		pub enum Command {
33		/// The version and build of this binary
34		Version {
35		/// Machine-readable output
36		#[arg(long)]
37		json: bool,
38		},
39		/// Make this machine's Spectra: record the owner's identity (read from
40		/// their OXY_HOME and proven by signing) and make the instance key
41		Init {
42		/// The owner's OXY_HOME (default: $OXY_HOME, else ~/.config/oxy)
43		#[arg(long)]
44		owner_home: Option<PathBuf>,
45		/// This instance's name (default: the host name)
46		#[arg(long)]
47		name: Option<String>,
48		},
49		/// The owner's and the instance's identities: show, refresh
50		Identity {
51		#[command(subcommand)]
52		command: IdentityCmd,
53		},
54		/// The checkouts agents work in: add, list
55		Project {
56		#[command(subcommand)]
57		command: ProjectCmd,
58		},
59		/// Agents, each its owner's delegate: add, list, disable
60		Agent {
61		#[command(subcommand)]
62		command: AgentCmd,
63		},
64		/// The ledger's own checks: verify, check, rebuild
65		Admin {
66		#[command(subcommand)]
67		command: Admin,
68		},
69		}
70
71		#[derive(Subcommand)]
72		pub enum IdentityCmd {
73		/// The owner and the instance as the ledger knows them
74		Show {
75		#[arg(long)]
76		json: bool,
77		},
78		/// Record the owner's current identity after `oxy identity delegate add\|remove`
79		Refresh {
80		#[arg(long)]
81		owner_home: Option<PathBuf>,
82		},
83		}
84
85		#[derive(Subcommand)]
86		pub enum ProjectCmd {
87		/// Register a checkout: its repository id, remote and pinned subrepos
88		Add {
89		path: PathBuf,
90		/// Its name (default: the directory's)
91		#[arg(long)]
92		name: Option<String>,
93		/// Its remote URL (default: the checkout's origin)
94		#[arg(long)]
95		remote: Option<String>,
96		#[arg(long)]
97		owner_home: Option<PathBuf>,
98		},
99		/// Every project with what it pins, what pins it, and its agents
100		List {
101		#[arg(long)]
102		json: bool,
103		},
104		}
105
106		#[derive(Subcommand)]
107		pub enum AgentCmd {
108		/// Make an agent's key in its own home and record it once you delegate to it
109		Add {
110		/// Lower-case letters, digits and dashes
111		name: String,
112		/// claude-code, antigravity, kimi-code, codex or other
113		#[arg(long)]
114		kind: String,
115		/// The project it works in
116		#[arg(long)]
117		project: String,
118		/// The agent's own OXY_HOME, where its key is made and kept
119		#[arg(long)]
120		home: PathBuf,
121		/// Bind the key to this Unix user: a request from another is refused
122		#[arg(long)]
123		uid: Option<u32>,
124		/// Bind the key to the Unix user of its first signed connection
125		#[arg(long, conflicts_with = "uid")]
126		learn_uid: bool,
127		/// How long to wait for your delegation, in seconds
128		#[arg(long, default_value_t = 600)]
129		wait: u64,
130		/// The owner's OXY_HOME
131		#[arg(long)]
132		owner_home: Option<PathBuf>,
133		},
134		/// Every agent with its owner, key, delegation and state
135		List {
136		#[arg(long)]
137		json: bool,
138		},
139		/// Refuse an agent's key from now on
140		Disable {
141		name: String,
142		#[arg(long)]
143		owner_home: Option<PathBuf>,
144		},
145		}
146
147		#[derive(Subcommand)]
148		pub enum Admin {
149		/// Recompute the hash chain and check every checkpoint and proof (exit 1 on any finding)
150		Verify {
151		/// Machine-readable output
152		#[arg(long)]
153		json: bool,
154		},
155		/// Whether the projections equal a rebuild from the ledger
156		Check,
157		/// Replay the ledger into every projection
158		Rebuild,
159		}
160
161		/// What every command needs: where the data lives.
162		pub struct Ctx {
163		pub data: PathBuf,
164		}
165
166		impl Ctx {
167		/// The ledger's database, which must exist.
168	32×	pub fn db(&self) -> Result<PathBuf> {
169	32×	let db = self.data.join("spectra.db");
170	32×	if !db.exists() {
171	1×	bail!("no Spectra in {} (run `spectra init`, or pass --data)", self.data.display());
172	31×	}
173	31×	Ok(db)
174	32×	}
175
176		/// The ledger, for writing: the instance key signs its checkpoints, and
177		/// the lock keeps any other writer out.
178	15×	pub async fn writer(&self) -> Result<spectra_core::ledger::Ledger> {
179	15×	let db = self.db()?;
180	15×	let instance = spectra_core::keys::KeyPair::instance(&self.data, "spectra")?;
181	15×	spectra_core::ledger::Ledger::open(&db, Some(instance)).await
182	15×	}
183
184		/// `[owner] home` from spectra.toml.
185	15×	pub fn config_owner_home(&self) -> Option<PathBuf> {
186	15×	let text = std::fs::read_to_string(self.data.join("spectra.toml")).ok()?;
187	9×	let t: toml::Table = text.parse().ok()?;
188	9×	t.get("owner")?.get("home")?.as_str().map(PathBuf::from)
189	15×	}
190		}
191
192	0×	fn default_data() -> PathBuf {
193	0×	if let Ok(x) = std::env::var("XDG_DATA_HOME") {
194	0×	return PathBuf::from(x).join("spectra");
195	0×	}
196	0×	let home = std::env::var("HOME").unwrap_or_else(\|_\| ".".into());
197	0×	PathBuf::from(home).join(".local").join("share").join("spectra")
198	0×	}
199
200	38×	fn runtime() -> Result<tokio::runtime::Runtime> {
201	38×	Ok(tokio::runtime::Builder::new_multi_thread().enable_all().build()?)
202	38×	}
203
204	38×	pub fn run() -> Result<i32> {
205	38×	let cli = Cli::parse();
206	38×	ui::init(cli.plain);
207	38×	let ctx = Ctx { data: cli.data.unwrap_or_else(default_data) };
208	38×	match cli.command {
209	0×	Command::Version { json } => version(json),
210	7×	Command::Init { owner_home, name } => runtime()?.block_on(identity::init(&ctx, owner_home, name)),
211	0×	Command::Identity { command } => runtime()?.block_on(async {
212	0×	match command {
213	0×	IdentityCmd::Show { json } => identity::show(&ctx, json).await,
214	0×	IdentityCmd::Refresh { owner_home } => identity::refresh(&ctx, owner_home).await,
215		}
216	0×	}),
217	9×	Command::Project { command } => runtime()?.block_on(async {
218	9×	match command {
219	7×	ProjectCmd::Add { path, name, remote, owner_home } => project::add(&ctx, &path, name, remote, owner_home).await,
220	2×	ProjectCmd::List { json } => project::list(&ctx, json).await,
221		}
222	9×	}),
223	8×	Command::Agent { command } => runtime()?.block_on(async {
224	8×	match command {
225	3×	AgentCmd::Add { name, kind, project, home, uid, learn_uid, wait, owner_home } => {
226	3×	agent::add(&ctx, agent::Add { name, kind, project, home, uid, learn_uid, wait_secs: wait, owner_home }).await
227		}
228	3×	AgentCmd::List { json } => agent::list(&ctx, json).await,
229	2×	AgentCmd::Disable { name, owner_home } => agent::disable(&ctx, &name, owner_home).await,
230		}
231	8×	}),
232	14×	Command::Admin { command } => runtime()?.block_on(async {
233	14×	match command {
234	9×	Admin::Verify { json } => admin::verify(&ctx, json).await,
235	4×	Admin::Check => admin::check(&ctx).await,
236	1×	Admin::Rebuild => admin::rebuild(&ctx).await,
237		}
238	14×	}),
239		}
240	38×	}
241
242	0×	fn version(as_json: bool) -> Result<i32> {
243	0×	if as_json {
244	0×	println!(
245	0×	"{}",
246	0×	serde_json::json!({
247	0×	"version": env!("CARGO_PKG_VERSION"),
248	0×	"build": env!("SPECTRA_BUILD_ID"),
249	0×	"mcp_protocol_versions": spectra_mcp::PROTOCOL_VERSIONS,
250	0×	"ledger_format": spectra_core::LEDGER_FORMAT,
251	0×	})
252	0×	);
253	0×	} else {
254	0×	println!("spectra {}", env!("SPECTRA_VERSION_LONG"));
255	0×	}
256	0×	Ok(0)
257	0×	}

Coverage / src/cli/mod.rs 61.3%

Keyboard