scv-server 0.3.0

Authoritative session and tool server for SCV
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

//! Unit tests for `src/control.rs`.

use std::path::PathBuf;

use scv_tools::delegation as delegations;

use super::*;

#[tokio::test]
async fn daemon_control_lists_and_stops_delegations() {
    use std::os::unix::process::CommandExt as _;
    let home = tempfile::tempdir().unwrap();
    let registry = DelegationRegistry::new(&scv_client::Layout::new(home.path()));
    let components = Arc::new(Mutex::new(components::Components::new(
        crate::test_support::test_instance("/unused"),
        PathBuf::from("/"),
    )));
    // A run owned by another live SCV process of the same instance.
    let mut owner = std::process::Command::new("sleep")
        .arg("30")
        .spawn()
        .unwrap();
    let mut agent = std::process::Command::new("sleep")
        .arg("30")
        .process_group(0)
        .spawn()
        .unwrap();
    let identity = |pid| delegations::ProcessIdentity::of(pid).unwrap();
    let record = delegations::DelegationRecord {
        handle: "codex-a1b2c3".into(),
        agent: "codex".into(),
        instance: registry.instance().into(),
        session: "session".into(),
        owner: identity(owner.id()),
        process: identity(agent.id()),
        pgid: agent.id(),
        cwd: "/work/project\u{7}".into(),
        started_unix: 1,
        depth: 1,
        conversation: Some("codex-2".into()),
        turn: Some(3),
    };
    std::fs::create_dir_all(registry.record_dir()).unwrap();
    std::fs::write(
        registry.record_dir().join("codex-a1b2c3.json"),
        serde_json::to_vec(&record).unwrap(),
    )
    .unwrap();
    let control = |command| daemon_control(&components, &registry, command);
    let Ok(status) = control(DaemonCommand::Status).await else {
        panic!("status failed");
    };
    assert_eq!(status.delegations.active, 1);
    assert!(status.delegations.entries.is_empty());
    let Ok(status) = control(DaemonCommand::Delegations { all: false }).await else {
        panic!("listing failed");
    };
    let [entry] = status.delegations.entries.as_slice() else {
        panic!("{:?}", status.delegations);
    };
    assert_eq!(entry.handle, "codex-a1b2c3");
    assert_eq!(entry.conversation.as_deref(), Some("codex-2"));
    assert_eq!(entry.turn, Some(3));
    assert_eq!(entry.pid, agent.id());
    assert_eq!(entry.owner_pid, owner.id());
    assert!(!entry.orphaned);
    assert_eq!(entry.processes, 1);
    for command in [
        DaemonCommand::DelegationKill {
            handle: Some("codex-nosuch".into()),
            orphans: false,
        },
        DaemonCommand::DelegationKill {
            handle: None,
            orphans: false,
        },
    ] {
        assert!(matches!(
            control(command).await,
            Err(ControlFailure::Delegation(_))
        ));
    }
    let Ok(status) = control(DaemonCommand::DelegationKill {
        handle: Some("codex-a1b2c3".into()),
        orphans: false,
    })
    .await
    else {
        panic!("kill failed");
    };
    assert_eq!(status.delegations.killed, ["codex-a1b2c3"]);
    assert!(agent.wait().unwrap().code().is_none());
    // Its live owner removes the record itself; once the owner is gone
    // the record is an orphan that an orphan sweep removes.
    owner.kill().unwrap();
    owner.wait().unwrap();
    let Ok(status) = control(DaemonCommand::Delegations { all: true }).await else {
        panic!("listing failed");
    };
    assert!(status.delegations.entries[0].orphaned);
    assert_eq!(status.delegations.active, 0);
    let Ok(_) = control(DaemonCommand::DelegationKill {
        handle: None,
        orphans: true,
    })
    .await
    else {
        panic!("orphan sweep failed");
    };
    assert!(registry.list(true).is_empty());
}