astrid 2026.9.2

Command-line interface for Astrid secure agent runtime
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

//! Parse tests for AOS host-plugin `mcp serve` argv.
use super::{Cli, Commands, McpCommands};
use clap::Parser;

#[test]
fn mcp_http_accepts_explicit_endpoint_credentials_and_workspace() {
    let parsed = Cli::try_parse_from([
        "astrid",
        "--principal",
        "codex-code",
        "mcp",
        "http",
        "--listen",
        "127.0.0.1:9000",
        "--token-file",
        "/tmp/token",
        "--workspace",
        "/tmp/project",
    ])
    .unwrap();
    let Some(Commands::Mcp {
        command:
            McpCommands::Http {
                listen,
                token_file,
                workspace,
            },
    }) = parsed.command
    else {
        panic!("expected MCP HTTP command");
    };
    assert_eq!(listen, Some("127.0.0.1:9000".parse().unwrap()));
    assert_eq!(token_file.unwrap(), std::path::PathBuf::from("/tmp/token"));
    assert_eq!(workspace.unwrap(), std::path::PathBuf::from("/tmp/project"));
}

#[test]
fn mcp_serve_accepts_aos_host_plugin_flags() {
    let parsed = Cli::try_parse_from([
        "astrid",
        "--principal",
        "codex-code",
        "mcp",
        "serve",
        "--workspace",
        "/tmp/project",
        "--request-timeout",
        "1d5m",
    ])
    .expect("AOS plugin argv must parse");
    match parsed.command {
        Some(Commands::Mcp {
            command:
                McpCommands::Serve {
                    workspace,
                    request_timeout,
                },
        }) => {
            assert_eq!(
                workspace.as_deref(),
                Some(std::path::Path::new("/tmp/project"))
            );
            assert_eq!(request_timeout.as_deref(), Some("1d5m"));
        },
        _ => panic!("expected mcp serve"),
    }
}

#[test]
fn mcp_attach_accepts_principal_after_subcommand() {
    let parsed = Cli::try_parse_from([
        "astrid",
        "mcp",
        "attach",
        "--principal",
        "codex-code",
        "--workspace",
        "/tmp/project",
    ])
    .expect("attach argv must parse");
    assert_eq!(parsed.principal.as_deref(), Some("codex-code"));
    match parsed.command {
        Some(Commands::Mcp {
            command: McpCommands::Attach { workspace },
        }) => assert_eq!(
            workspace.as_deref(),
            Some(std::path::Path::new("/tmp/project"))
        ),
        _ => panic!("expected mcp attach"),
    }
}

#[test]
fn mcp_ready_defaults_to_hook_format() {
    let parsed = Cli::try_parse_from(["astrid", "mcp", "ready"]).expect("ready argv must parse");
    match parsed.command {
        Some(Commands::Mcp {
            command: McpCommands::Ready { format },
        }) => assert_eq!(format, "hook"),
        _ => panic!("expected mcp ready"),
    }
}

#[test]
fn mcp_ready_accepts_explicit_hook_format_after_subcommand() {
    let parsed = Cli::try_parse_from(["astrid", "mcp", "ready", "--format", "hook"])
        .expect("ready format argv must parse");
    match parsed.command {
        Some(Commands::Mcp {
            command: McpCommands::Ready { format },
        }) => assert_eq!(format, "hook"),
        _ => panic!("expected mcp ready"),
    }
}