open.rs 38.0%

27 of 71 lines run, 5 of 22 functions · run #31 on main · run missed

//! `spectra open`: sign in to Radar (spec §8.3). The owner's CLI signs a
//! request for a one-time link with the owner's key; the link, valid for a
//! minute, opens a level-2 browser session.

use super::identity::{owner_home, recorded_owner};
use super::{ui, Ctx};
use anyhow::{bail, Context, Result};
use spectra_core::ledger::Ledger;
use spectra_mcp::client::Client;
use std::path::PathBuf;

/// The sign-in link, landing on `page` if one is named.
fn with_page(url: String, page: Option<&str>) -> String {
    match page.filter(|p| !p.is_empty() && *p != "live") {
        Some(p) => format!("{url}&next={}", p.trim_start_matches('/')),
        None => url,
    }
}

pub async fn open(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, page: Option<&str>) -> Result<i32> {
    let socket = ctx.socket();
    if !Client::alive(&socket).await {
        bail!("Spectra is not serving {} (spectra serve)", ctx.data.display());
    }
    let home = owner_home(ctx, owner_home_flag);
    let ledger = Ledger::open_read_only(&ctx.db()?).await?;
    let owner = recorded_owner(&ledger, &home).await?;
    let r = Client::new(&socket, Some(owner)).send("POST", "/radar/link", &[], Vec::new()).await?;
    if r.status != 200 {
        bail!("the daemon refused the sign-in: {}", String::from_utf8_lossy(&r.body));
    }
    let url = r.json()?.get("url").and_then(|u| u.as_str()).map(String::from).context("no link in the answer")?;
    let url = with_page(url, page);
    println!("{} {}", ui::done("Signed"), ui::subject("a one-time link to Radar, good for a minute"));
    show(&url, launch);
    Ok(0)
}

fn show(url: &str, launch: bool) {
    println!("  {}", ui::id(url));
    if launch
        && std::process::Command::new("xdg-open")
            .arg(url)
            .stdout(std::process::Stdio::null())
            .stderr(std::process::Stdio::null())
            .spawn()
            .is_ok()
    {
        println!("  {} {}", ui::note(), ui::dim("opened in your browser"));
    }
}

/// `spectra open` with Spectra on another machine (spec §8.6): serve Radar
/// through a loopback proxy to the pinned server, and sign in through it.
pub async fn open_remote(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, port: u16, page: Option<&str>) -> Result<i32> {
    let cfg = ctx.remote()?.context("no server configured")?;
    let home = owner_home(ctx, owner_home_flag);
    let listener = tokio::net::TcpListener::bind(("127.0.0.1", port))
        .await
        .with_context(|| format!("binding 127.0.0.1:{port} for Radar (another `spectra open` running? --port picks another)"))?;
    let port = listener.local_addr()?.port();
    let client = ctx.owner_client(&home).await?.context("no server configured")?;
    let r = client.send("POST", "/radar/link", &[], Vec::new()).await?;
    if r.status != 200 {
        bail!("the server refused the sign-in: {}", String::from_utf8_lossy(&r.body));
    }
    let url = r.json()?.get("url").and_then(|u| u.as_str()).map(String::from).context("no link in the answer")?;
    let local = with_page(spectra_mcp::proxy::local_link(&url, port), page);
    println!("{} {}{}{}", ui::done("Serving"), ui::subject("Radar"), ui::sep(), ui::dim(format!("from {} over pinned TLS", cfg.server)));
    println!("{}", ui::kv("radar", format!("http://127.0.0.1:{port}")));
    println!("{} {}", ui::done("Signed"), ui::subject("a one-time link, good for a minute"));
    show(&local, launch);
    println!("  {} {}", ui::note(), ui::dim("Ctrl-C stops the proxy"));
    use std::io::Write;
    std::io::stdout().flush().ok();
    let app = spectra_mcp::proxy::router(cfg.endpoint()?, port);
    axum::serve(listener, app)
        .with_graceful_shutdown(async {
            let _ = tokio::signal::ctrl_c().await;
        })
        .await?;
    Ok(0)
}

1		//! `spectra open`: sign in to Radar (spec §8.3). The owner's CLI signs a
2		//! request for a one-time link with the owner's key; the link, valid for a
3		//! minute, opens a level-2 browser session.
4
5		use super::identity::{owner_home, recorded_owner};
6		use super::{ui, Ctx};
7		use anyhow::{bail, Context, Result};
8		use spectra_core::ledger::Ledger;
9		use spectra_mcp::client::Client;
10		use std::path::PathBuf;
11
12		/// The sign-in link, landing on `page` if one is named.
13	1×	fn with_page(url: String, page: Option<&str>) -> String {
14	1×	match page.filter(\|p\| !p.is_empty() && *p != "live") {
15	0×	Some(p) => format!("{url}&next={}", p.trim_start_matches('/')),
16	1×	None => url,
17		}
18	1×	}
19
20	1×	pub async fn open(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, page: Option<&str>) -> Result<i32> {
21	1×	let socket = ctx.socket();
22	1×	if !Client::alive(&socket).await {
23	0×	bail!("Spectra is not serving {} (spectra serve)", ctx.data.display());
24	1×	}
25	1×	let home = owner_home(ctx, owner_home_flag);
26	1×	let ledger = Ledger::open_read_only(&ctx.db()?).await?;
27	1×	let owner = recorded_owner(&ledger, &home).await?;
28	1×	let r = Client::new(&socket, Some(owner)).send("POST", "/radar/link", &[], Vec::new()).await?;
29	1×	if r.status != 200 {
30	0×	bail!("the daemon refused the sign-in: {}", String::from_utf8_lossy(&r.body));
31	1×	}
32	1×	let url = r.json()?.get("url").and_then(\|u\| u.as_str()).map(String::from).context("no link in the answer")?;
33	1×	let url = with_page(url, page);
34	1×	println!("{} {}", ui::done("Signed"), ui::subject("a one-time link to Radar, good for a minute"));
35	1×	show(&url, launch);
36	1×	Ok(0)
37	1×	}
38
39	1×	fn show(url: &str, launch: bool) {
40	1×	println!(" {}", ui::id(url));
41	1×	if launch
42	0×	&& std::process::Command::new("xdg-open")
43	0×	.arg(url)
44	0×	.stdout(std::process::Stdio::null())
45	0×	.stderr(std::process::Stdio::null())
46	0×	.spawn()
47	0×	.is_ok()
48	0×	{
49	0×	println!(" {} {}", ui::note(), ui::dim("opened in your browser"));
50	1×	}
51	1×	}
52
53		/// `spectra open` with Spectra on another machine (spec §8.6): serve Radar
54		/// through a loopback proxy to the pinned server, and sign in through it.
55	0×	pub async fn open_remote(ctx: &Ctx, owner_home_flag: Option<PathBuf>, launch: bool, port: u16, page: Option<&str>) -> Result<i32> {
56	0×	let cfg = ctx.remote()?.context("no server configured")?;
57	0×	let home = owner_home(ctx, owner_home_flag);
58	0×	let listener = tokio::net::TcpListener::bind(("127.0.0.1", port))
59	0×	.await
60	0×	.with_context(\|\| format!("binding 127.0.0.1:{port} for Radar (another `spectra open` running? --port picks another)"))?;
61	0×	let port = listener.local_addr()?.port();
62	0×	let client = ctx.owner_client(&home).await?.context("no server configured")?;
63	0×	let r = client.send("POST", "/radar/link", &[], Vec::new()).await?;
64	0×	if r.status != 200 {
65	0×	bail!("the server refused the sign-in: {}", String::from_utf8_lossy(&r.body));
66	0×	}
67	0×	let url = r.json()?.get("url").and_then(\|u\| u.as_str()).map(String::from).context("no link in the answer")?;
68	0×	let local = with_page(spectra_mcp::proxy::local_link(&url, port), page);
69	0×	println!("{} {}{}{}", ui::done("Serving"), ui::subject("Radar"), ui::sep(), ui::dim(format!("from {} over pinned TLS", cfg.server)));
70	0×	println!("{}", ui::kv("radar", format!("http://127.0.0.1:{port}")));
71	0×	println!("{} {}", ui::done("Signed"), ui::subject("a one-time link, good for a minute"));
72	0×	show(&local, launch);
73	0×	println!(" {} {}", ui::note(), ui::dim("Ctrl-C stops the proxy"));
74		use std::io::Write;
75	0×	std::io::stdout().flush().ok();
76	0×	let app = spectra_mcp::proxy::router(cfg.endpoint()?, port);
77	0×	axum::serve(listener, app)
78	0×	.with_graceful_shutdown(async {
79	0×	let _ = tokio::signal::ctrl_c().await;
80	0×	})
81	0×	.await?;
82	0×	Ok(0)
83	0×	}

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

Coverage / src/cli/open.rs 38.0%

Keyboard