kaizen-cli 0.1.41

Distributable agent observability: real-time-tailable sessions, agile-style retros, and repo-level improvement (Cursor, Claude Code, Codex). SQLite, redact before any sync you enable.
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

use crate::bin_kaizen::args::*;

pub(super) fn daemon(cmd: DaemonCommand) -> anyhow::Result<()> {
    match cmd {
        DaemonCommand::Start { background } => daemon_start(background),
        DaemonCommand::Stop => {
            println!("{}", kaizen::daemon::stop()?);
            Ok(())
        }
        DaemonCommand::Status => daemon_status(),
    }
}

fn daemon_start(background: bool) -> anyhow::Result<()> {
    if !background {
        return kaizen::daemon::start_foreground();
    }
    let started = kaizen::daemon::start_background()?;
    for line in background_start_lines(&started) {
        println!("{line}");
    }
    Ok(())
}

fn background_start_lines(started: &kaizen::daemon::BackgroundStart) -> Vec<String> {
    let lines = [
        format!("daemon {}", background_state(started)),
        format!("pid: {}", started.pid),
        format!("socket: {}", started.paths.sock.display()),
        format!("log: {}", started.paths.log.display()),
    ];
    lines.into_iter().chain(web_line(started)).collect()
}

fn background_state(started: &kaizen::daemon::BackgroundStart) -> &'static str {
    match started.already_running {
        true => "already running",
        false => "started",
    }
}

fn web_line(started: &kaizen::daemon::BackgroundStart) -> Option<String> {
    started.web.as_ref().map(|web| format!("web: {}", web.url))
}

fn daemon_status() -> anyhow::Result<()> {
    match kaizen::daemon::status_outcome()? {
        kaizen::daemon::DaemonStatusOutcome::Running(st) => print_running_daemon(st),
        kaizen::daemon::DaemonStatusOutcome::Stopped { socket } => {
            println!("status: stopped");
            println!("socket: {}", socket.display());
        }
    }
    Ok(())
}

fn print_running_daemon(st: kaizen::ipc::DaemonStatus) {
    println!("status: running");
    println!("pid: {}", st.pid);
    println!("uptime_ms: {}", st.uptime_ms);
    println!("queue_depth: {}", st.queue_depth);
    println!(
        "last_error: {}",
        st.last_error.unwrap_or_else(|| "-".to_string())
    );
    if let Some(web) = st.web {
        println!("web: {}", web.url);
    }
    for capture in st.capture {
        print_capture(capture);
    }
}

fn print_capture(capture: kaizen::ipc::CaptureStatus) {
    println!("capture: {}", capture.workspace);
    println!("  deep: {}", capture.deep);
    println!("  hooks: {}", capture.hooks.len());
    println!("  watchers: {}", capture.watchers.len());
    println!("  proxies: {}", capture.proxies.len());
    if !capture.errors.is_empty() {
        println!("  errors: {}", capture.errors.join("; "));
    }
}

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

    #[test]
    fn background_start_output_includes_web_url() {
        let started = background_start();
        assert!(
            background_start_lines(&started)
                .contains(&"web: http://127.0.0.1:7878/?token=t".to_string())
        );
    }

    fn background_start() -> kaizen::daemon::BackgroundStart {
        kaizen::daemon::BackgroundStart {
            pid: 42,
            paths: runtime_paths(),
            already_running: false,
            web: Some(web_endpoint()),
        }
    }

    fn web_endpoint() -> kaizen::ipc::WebEndpoint {
        kaizen::ipc::WebEndpoint {
            listen: "127.0.0.1:7878".to_string(),
            url: "http://127.0.0.1:7878/?token=t".to_string(),
            token: "t".to_string(),
        }
    }

    fn runtime_paths() -> kaizen::daemon::RuntimePaths {
        kaizen::daemon::RuntimePaths {
            dir: "/tmp/k".into(),
            pid: "/tmp/k/daemon.pid".into(),
            sock: "/tmp/k/daemon.sock".into(),
            log: "/tmp/k/daemon.log".into(),
        }
    }
}