zc2 0.0.53

P2P compute broker with yen-denominated billing, WAL, and broker mesh support
//! `zc agent`: the loopback control service that supervises this Mac's
//! sharing and serves the menu-bar app and widget
//! (spec docs/superpowers/specs/2026-09-13-macos-widget-design.md §6).

pub mod cli;
pub mod client;
pub mod config;
pub mod core;
pub mod deployments;
pub mod events;
pub mod files;
pub mod handoff;
pub mod history;
pub mod host_runner;
pub mod hosting;
pub mod hosting_api;
pub mod hosting_loop;
pub mod hub;
pub mod hubwire;
pub mod images;
pub mod jobs;
pub mod jobs_cli;
pub mod launchd;
pub mod ledger;
pub mod link_cli;
pub mod local_nodes;
pub mod logs;
pub mod merge;
pub mod mesh;
pub mod node_manager;
pub mod offers;
pub mod outbox;
pub mod owner;
pub mod plan;
pub mod policy_api;
pub mod resources;
pub mod run;
pub mod runners;
pub mod schtasks;
pub mod server;
pub mod setup_cli;
pub mod summary;
pub mod summary_v2;
pub mod supervisor;
pub mod systemd;
#[cfg(test)]
pub mod testbin;
pub mod vpn_watch;
pub mod watchdog;

/// The arguments the Windows task passes to `zc agent run` (`schtasks.rs`),
/// which cannot set environment variables or redirect output itself:
/// `--set KEY=VALUE` (repeatable) and `--service-log <file>`. A plain
/// `zc agent run` has none.
#[derive(Debug, Default, PartialEq, Eq)]
pub struct ServiceArgs {
    /// `--set KEY=VALUE`, in order.
    pub env: Vec<(String, String)>,
    /// `--service-log <file>`.
    pub log: Option<String>,
}

pub fn parse_service_args(args: &[String]) -> Result<ServiceArgs, String> {
    let (mut env, mut log) = (Vec::new(), None);
    let mut it = args.iter();
    while let Some(a) = it.next() {
        match a.as_str() {
            "--set" => {
                let kv = it.next().ok_or("--set needs KEY=VALUE")?;
                let (k, v) = kv
                    .split_once('=')
                    .ok_or_else(|| format!("--set {kv}: expected KEY=VALUE"))?;
                if !launchd::CARRIED_ENV.contains(&k) {
                    return Err(format!("--set {k}: not an agent setting"));
                }
                env.push((k.to_string(), v.to_string()));
            }
            "--service-log" => log = Some(it.next().ok_or("--service-log needs a file")?.clone()),
            other => return Err(format!("unexpected argument '{other}'")),
        }
    }
    Ok(ServiceArgs { env, log })
}

fn apply_service_args(args: &[String]) -> Result<(), String> {
    let ServiceArgs { env, log } = parse_service_args(args)?;
    for (k, v) in env {
        std::env::set_var(k, v);
    }
    if let Some(log) = log {
        #[cfg(windows)]
        schtasks::redirect_std_to(std::path::Path::new(&log))
            .map_err(|e| format!("--service-log {log}: {e}"))?;
        #[cfg(not(windows))]
        return Err(format!(
            "--service-log {log}: only the Windows agent task uses it"
        ));
    }
    Ok(())
}

/// `zc agent run | install | uninstall | status [--json]` → exit code.
pub fn run_cli(args: &[String], json: bool) -> i32 {
    match args.first().map(String::as_str).unwrap_or("status") {
        "run" => match apply_service_args(&args[1..])
            .and_then(|()| config::AgentConfig::from_env().map_err(|e| e.to_string()))
        {
            Ok(cfg) => run::run(cfg),
            Err(e) => {
                eprintln!("zc agent: {e}");
                1
            }
        },
        "install" => cli::install(),
        "uninstall" => cli::uninstall(),
        "status" => cli::status(json),
        other => {
            eprintln!("usage: zc agent [run|install|uninstall|status [--json]] (got '{other}')");
            2
        }
    }
}

#[cfg(test)]
mod service_args_tests {
    use super::{parse_service_args, ServiceArgs};

    fn v(a: &[&str]) -> Vec<String> {
        a.iter().map(|s| s.to_string()).collect()
    }

    #[test]
    fn a_plain_agent_run_has_no_service_args() {
        assert_eq!(parse_service_args(&[]).unwrap(), ServiceArgs::default());
    }

    #[test]
    fn the_windows_task_args_carry_settings_and_the_log() {
        let ServiceArgs { env, log } = parse_service_args(&v(&[
            "--service-log",
            r"C:\Users\jo\.zakuro\agent\agent.log",
            "--set",
            r"ZAKURO_HOME=D:\zk=1",
        ]))
        .unwrap();
        assert_eq!(
            env,
            vec![("ZAKURO_HOME".to_string(), r"D:\zk=1".to_string())]
        );
        assert_eq!(log.as_deref(), Some(r"C:\Users\jo\.zakuro\agent\agent.log"));
    }

    #[test]
    fn only_agent_settings_and_known_flags_are_accepted() {
        assert!(parse_service_args(&v(&["--set", "PATH=/tmp"])).is_err());
        assert!(parse_service_args(&v(&["--set", "ZAKURO_HOME"])).is_err());
        assert!(parse_service_args(&v(&["--set"])).is_err());
        assert!(parse_service_args(&v(&["--service-log"])).is_err());
        assert!(parse_service_args(&v(&["--json"])).is_err());
    }
}