clash 0.7.1

Command Line Agent Safety Harness — permission policies for coding agents
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

//! GitHub Copilot CLI hook protocol implementation.
//!
//! Copilot uses "approve"/"deny" decisions.

use anyhow::Result;
use serde_json::Value;

use super::protocol::{HookProtocol, json_str};
use super::{AgentKind, resolve_tool_name};
use crate::hooks::ToolUseHookInput;

pub struct CopilotProtocol;

impl HookProtocol for CopilotProtocol {
    fn agent(&self) -> AgentKind {
        AgentKind::Copilot
    }

    fn parse_tool_use(&self, raw: &Value) -> Result<ToolUseHookInput> {
        let tool_name = json_str(raw, "tool_name").to_string();
        let original = tool_name.clone();
        let resolved = resolve_tool_name(AgentKind::Copilot, &tool_name).to_string();

        Ok(ToolUseHookInput {
            session_id: json_str(raw, "session_id").to_string(),
            transcript_path: json_str(raw, "transcript_path").to_string(),
            cwd: json_str(raw, "cwd").to_string(),
            permission_mode: "default".to_string(),
            hook_event_name: json_str(raw, "hook_event_name").to_string(),
            tool_name: resolved,
            tool_input: raw
                .get("tool_input")
                .cloned()
                .unwrap_or(Value::Object(serde_json::Map::new())),
            tool_use_id: None,
            tool_response: raw.get("tool_response").cloned(),
            agent: Some(AgentKind::Copilot),
            original_tool_name: Some(original),
        })
    }

    // Copilot uses "approve"/"deny"
    fn format_allow(
        &self,
        reason: Option<&str>,
        _context: Option<&str>,
        _updated_input: Option<Value>,
    ) -> Value {
        let mut output = serde_json::json!({ "decision": "approve" });
        if let Some(r) = reason {
            output["reason"] = Value::String(r.to_string());
        }
        output
    }

    fn format_deny(&self, reason: &str, _context: Option<&str>) -> Value {
        serde_json::json!({ "decision": "deny", "reason": reason })
    }

    fn format_ask(&self, _reason: Option<&str>, _context: Option<&str>) -> Value {
        serde_json::json!({ "decision": "approve" })
    }
}

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

    #[test]
    fn parse_copilot_bash() {
        let raw = serde_json::json!({
            "session_id": "cp-123",
            "cwd": "/home/user",
            "hook_event_name": "preToolUse",
            "tool_name": "bash",
            "tool_input": {"command": "git status"}
        });
        let input = CopilotProtocol.parse_tool_use(&raw).unwrap();
        assert_eq!(input.tool_name, "Bash");
    }

    #[test]
    fn format_allow_copilot() {
        assert_eq!(
            CopilotProtocol.format_allow(None, None, None)["decision"],
            "approve"
        );
    }

    #[test]
    fn format_deny_copilot() {
        assert_eq!(CopilotProtocol.format_deny("no", None)["decision"], "deny");
    }
}