netsky 0.1.6

netsky CLI: the viable system launcher and subcommand dispatcher
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! `netsky up [N] [--type claude|codex]` — spawn agent0 + N clones + agentinfinity watchdog.
//! Idempotent. Attaches to agent0 when interactive and not already inside tmux.
//!
//! `--type` picks the runtime for clones. agent0 is always claude, and
//! agentinfinity is always claude — it's the watchdog, not a clone, and
//! its repair logic is pinned to the claude CLI surface (agentinit, TOS
//! dismissal, permissions-watcher). Mixing runtimes across clones is
//! still possible via
//! `netsky agent N --type <other>` after `netsky up` returns.

use std::process::Command;

use netsky_core::agent::AgentId;
use netsky_core::consts::{AGENT0_NAME, TMUX_BIN};
use netsky_core::runtime::CodexConfig;
use netsky_core::runtime::Runtime;
use netsky_core::spawn::{self, SpawnOptions, SpawnOutcome};
use netsky_db::SessionEvent;

use crate::cli::AgentType;
use crate::cmd::init;
use crate::observability;

pub fn run(n: u32, agent_type: AgentType) -> netsky_core::Result<()> {
    let root = require_home_netsky_cwd()?;
    if !root.join(".agents/skills").is_dir() {
        init::run(Some(root.clone()), false)?;
    }

    for i in 0..=n {
        let agent = AgentId::from_number(i);
        let runtime = runtime_for(agent, agent_type);
        let opts = SpawnOptions {
            runtime,
            cwd: root.clone(),
        };
        announce(agent, spawn::spawn(agent, &opts)?, &opts);
    }

    // Ensure the watchdog is up. Idempotent: netsky-restart never kills
    // agentinfinity, so this is a no-op in steady state. Watchdog stays
    // on claude regardless of --type; the repair logic assumes the
    // claude CLI surface.
    {
        let agent = AgentId::Agentinfinity;
        let opts = SpawnOptions::defaults_for(agent, root.clone());
        announce(agent, spawn::spawn(agent, &opts)?, &opts);
    }

    observability::record_session(netsky_core::consts::AGENT0_NAME, 0, SessionEvent::Up);

    if should_attach_agent0() {
        let _ = Command::new(TMUX_BIN)
            .args(["attach", "-t", AGENT0_NAME])
            .status();
    }
    Ok(())
}

fn require_home_netsky_cwd() -> netsky_core::Result<std::path::PathBuf> {
    let home = netsky_core::paths::home();
    let expected = home.join("netsky");
    let cwd = std::env::current_dir()?;
    let cwd_canon = std::fs::canonicalize(&cwd).unwrap_or(cwd);
    let expected_canon = std::fs::canonicalize(&expected).unwrap_or(expected.clone());
    if cwd_canon != expected_canon {
        netsky_core::bail!(
            "netsky up: must run from ~/netsky (got {})",
            cwd_canon.display(),
        );
    }
    Ok(expected_canon)
}

fn runtime_for(agent: AgentId, agent_type: AgentType) -> Runtime {
    if agent.is_agent0() {
        return Runtime::defaults_for(agent);
    }
    match agent_type {
        AgentType::Claude => Runtime::defaults_for(agent),
        AgentType::Codex => Runtime::Codex(CodexConfig::defaults_for()),
    }
}

fn announce(agent: AgentId, outcome: SpawnOutcome, opts: &SpawnOptions) {
    match outcome {
        SpawnOutcome::AlreadyUp => {
            println!("[netsky up] '{}' already up", agent);
        }
        SpawnOutcome::Spawned => {
            println!(
                "[netsky up] spawned '{}' ({})",
                agent,
                opts.runtime.describe()
            );
        }
    }
}

/// True iff we should attach to agent0: interactive stdout + not already
/// inside a tmux client. Matches `bin/netsky` up-path behavior.
fn should_attach_agent0() -> bool {
    use std::io::IsTerminal;
    std::io::stdout().is_terminal() && std::env::var("TMUX").is_err()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn runtime_for_claude_yields_claude_runtime() {
        let rt = runtime_for(AgentId::Agent0, AgentType::Claude);
        assert_eq!(rt.name(), "claude");
    }

    #[test]
    fn runtime_for_codex_keeps_agent0_on_claude() {
        // agent0 stays on Claude even when the default is codex.
        let rt = runtime_for(AgentId::Agent0, AgentType::Codex);
        assert_eq!(rt.name(), "claude");
    }

    #[test]
    fn runtime_for_codex_yields_codex_runtime_for_clones() {
        let rt = runtime_for(AgentId::Clone(4), AgentType::Codex);
        assert_eq!(rt.name(), "codex");
    }
}