acp-cli 0.2.2

Headless CLI client for the Agent Client Protocol (ACP)
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

use acp_cli::bridge::{PermissionKind, PermissionOption, PermissionOutcome, ToolCallInfo};
use acp_cli::client::permissions::{PermissionMode, resolve_permission};

fn make_tool(name: &str) -> ToolCallInfo {
    ToolCallInfo {
        name: name.to_string(),
        description: None,
    }
}

fn make_options() -> Vec<PermissionOption> {
    vec![
        PermissionOption {
            option_id: "deny-1".to_string(),
            name: "Deny".to_string(),
            kind: PermissionKind::Deny,
        },
        PermissionOption {
            option_id: "allow-1".to_string(),
            name: "Allow".to_string(),
            kind: PermissionKind::Allow,
        },
    ]
}

#[test]
fn approve_all_selects_first_allow() {
    let tool = make_tool("Bash");
    let options = make_options();
    let outcome = resolve_permission(&tool, &options, &PermissionMode::ApproveAll);

    match outcome {
        PermissionOutcome::Selected { option_id } => {
            assert_eq!(option_id, "allow-1");
        }
        PermissionOutcome::Cancelled => panic!("expected Selected, got Cancelled"),
    }
}

#[test]
fn approve_reads_denies_write_tools() {
    let options = make_options();

    for tool_name in &["Edit", "Bash", "Write"] {
        let tool = make_tool(tool_name);
        let outcome = resolve_permission(&tool, &options, &PermissionMode::ApproveReads);

        assert!(
            matches!(outcome, PermissionOutcome::Cancelled),
            "expected Cancelled for write tool '{}', got Selected",
            tool_name
        );
    }
}

#[test]
fn approve_reads_allows_read_tools() {
    let options = make_options();

    for tool_name in &["Read", "Glob", "Grep"] {
        let tool = make_tool(tool_name);
        let outcome = resolve_permission(&tool, &options, &PermissionMode::ApproveReads);

        match outcome {
            PermissionOutcome::Selected { option_id } => {
                assert_eq!(
                    option_id, "allow-1",
                    "wrong option selected for '{}'",
                    tool_name
                );
            }
            PermissionOutcome::Cancelled => {
                panic!(
                    "expected Selected for read tool '{}', got Cancelled",
                    tool_name
                );
            }
        }
    }
}

#[test]
fn deny_all_cancels() {
    let tool = make_tool("Read");
    let options = make_options();
    let outcome = resolve_permission(&tool, &options, &PermissionMode::DenyAll);

    assert!(
        matches!(outcome, PermissionOutcome::Cancelled),
        "expected Cancelled for DenyAll mode"
    );
}

#[test]
fn approve_all_with_no_allow_option_cancels() {
    let tool = make_tool("Bash");
    let options = vec![PermissionOption {
        option_id: "deny-only".to_string(),
        name: "Deny".to_string(),
        kind: PermissionKind::Deny,
    }];
    let outcome = resolve_permission(&tool, &options, &PermissionMode::ApproveAll);

    assert!(
        matches!(outcome, PermissionOutcome::Cancelled),
        "expected Cancelled when no Allow option exists"
    );
}