Coverage / src/cli/setup.rs 72.5%

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

    let home = owner_home(ctx, None);

    let identity = spectra_core::keys::KeyPair::load_home(&home).ok();

    let remote = ctx.remote()?;

    let initialised = ctx.data.join("spectra.db").exists();

    let serving = initialised && Client::alive(&ctx.socket()).await;

    let reachable = match &remote {

        None => serving,

    let v = json!({

        "version": env!("SPECTRA_VERSION_LONG"),

        "home": home.display().to_string(),

        "identity": identity.as_ref().map(|p| json!({ "name": p.identity.name, "key": p.key.to_hex() })),

        "server": remote.as_ref().map(|c| json!({ "url": c.server, "instance": c.instance })),

        "local": { "data": ctx.data.display().to_string(), "initialised": initialised, "serving": serving },

        "reachable": reachable,

    if as_json {

        println!("{v}");

        return Ok(0);

}

pub async fn probe(url: &str, as_json: bool) -> Result<i32> {

    let addr = host_port(url)?;

    let seen = Pinned::new(None);

    let c = Client::at(Endpoint::Tls { addr: addr.clone(), config: seen.client_config()? }, None);

    let r = c.send("GET", "/api/v1/instance", &[], vec![]).await.with_context(|| format!("reaching https://{addr}"))?;

    if r.status != 200 {

    }

    let answer = r.json()?;

    let (_, pin) = seen.seen().context("the server showed no certificate")?;

    let checked = spectra_mcp::instance::check(&answer, &pin)?;

    let mine = spectra_core::keys::KeyPair::load_home(&spectra_core::keys::default_home()).ok();

    let waiting = answer.get("named_owner").and_then(Value::as_str).map(String::from);

    let v = json!({

        "url": format!("https://{addr}"),

        "name": checked.name,

        "instance": checked.instance.hash().to_hex(),

        "owner": checked.owner,

        "waiting_for": waiting,

        "yours": mine.as_ref().is_some_and(|m| {

            let me = m.key.to_hex();

            checked.owner.as_deref() == Some(me.as_str()) || waiting.as_deref() == Some(me.as_str())

        }),

        "tls_spki": hex::encode(pin),

    if as_json {

        println!("{v}");

    } else {

    Ok(0)

}

pub async fn bridge(ctx: &Ctx, port: u16, owner_home_flag: Option<PathBuf>) -> Result<i32> {

    let home = owner_home(ctx, owner_home_flag);

    let client =

        ctx.owner_client(&home).await?.context("no Spectra to bridge to: spectra init here, or spectra connect https://HOST:7350")?;

    let listener = tokio::net::TcpListener::bind(("127.0.0.1", port)).await.with_context(|| format!("binding 127.0.0.1:{port}"))?;

    let port = listener.local_addr()?.port();

    let token = spectra_mcp::bridge::token();

    println!("{}", json!({ "url": format!("http://127.0.0.1:{port}"), "token": token }));

    std::io::stdout().flush().ok();

    let app = spectra_mcp::bridge::router(client, token, port);

    axum::serve(listener, app)

        .with_graceful_shutdown(async {

            let stdin = async {

                let mut buf = [0u8; 256];

                let mut input = tokio::io::stdin();

                    match tokio::io::AsyncReadExt::read(&mut input, &mut buf).await {

                        Ok(0) | Err(_) => return,

            };

            tokio::select! {

                _ = stdin => {}

                _ = tokio::signal::ctrl_c() => {}

        })

        .await?;

    Ok(0)

}