ralph-agent-loop 0.4.0

A Rust CLI for managing AI agent loops with a structured JSON task queue
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

//! Daemon status command implementation.
//!
//! Responsibilities:
//! - Display daemon runtime status to users (running/stopped/indeterminate).
//! - Report daemon PID, start time, and command when running.
//! - Detect and clean up stale state files when the daemon is not running.
//! - Provide manual cleanup instructions for indeterminate states.
//!
//! Not handled here:
//! - Starting or stopping the daemon (see `super::start` and `super::stop`).
//! - Daemon log inspection (see `super::logs`).
//! - PID liveness checks themselves (handled in `crate::lock`).
//!
//! Invariants/assumptions:
//! - State file lives at `{cache_dir}/daemon.json`.
//! - Lock directory lives at `{cache_dir}/daemon.lock`.
//! - Uses `PidLiveness` to determine if the daemon process is actually running.

use crate::config::Resolved;
use crate::lock::PidLiveness;
use anyhow::Result;

use super::{
    clear_daemon_runtime_artifacts, daemon_pid_liveness, get_daemon_state,
    manual_daemon_cleanup_instructions,
};

/// Show daemon status.
pub fn status(resolved: &Resolved) -> Result<()> {
    let cache_dir = resolved.repo_root.join(".ralph/cache");

    match get_daemon_state(&cache_dir)? {
        Some(state) => match daemon_pid_liveness(state.pid) {
            PidLiveness::Running => {
                println!("Daemon is running");
                println!("  PID: {}", state.pid);
                println!("  Started: {}", state.started_at);
                println!("  Command: {}", state.command);
            }
            PidLiveness::NotRunning => {
                println!("Daemon is not running (stale state file detected)");
                println!("  Last PID: {}", state.pid);
                println!("  Last started: {}", state.started_at);
                clear_daemon_runtime_artifacts(&cache_dir, true);
            }
            PidLiveness::Indeterminate => {
                println!(
                    "Daemon PID liveness is indeterminate; preserving state/lock \
                         to avoid concurrent supervisors."
                );
                println!("  PID: {}", state.pid);
                println!("  Started: {}", state.started_at);
                println!("  Command: {}", state.command);
                println!();
                println!("{}", manual_daemon_cleanup_instructions(&cache_dir));
            }
        },
        None => {
            println!("Daemon is not running");
        }
    }

    Ok(())
}