codescout 0.14.0

High-performance coding agent toolkit MCP server
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

//! `approve_write` tool.

use serde_json::{json, Value};

use super::{RecoverableError, Tool, ToolContext};

pub struct ApproveWrite;

#[async_trait::async_trait]
impl Tool for ApproveWrite {
    fn name(&self) -> &str {
        "approve_write"
    }

    fn description(&self) -> &str {
        "Grant write access to a directory outside the project root for this session. \
         Session-scoped — cleared on server restart. Call before edit_file, create_file, \
         edit_code, or edit_markdown on paths outside the project. Protected paths (e.g. ~/.ssh) \
         cannot be approved."
    }

    fn is_write(&self, _input: &Value) -> bool {
        true
    }

    fn input_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "Absolute or project-relative path to the directory to approve for writing."
                }
            },
            "required": ["path"]
        })
    }

    async fn call(&self, input: Value, ctx: &ToolContext) -> anyhow::Result<Value> {
        super::guard_worktree_write(ctx).await?;
        let raw = super::require_str_param(&input, "path")?;

        let root = ctx.agent.require_project_root().await.map_err(|_| {
            RecoverableError::new("approve_write: no active project — activate a project first")
        })?;

        let security = ctx.agent.security_config().await;

        if !security.file_write_enabled {
            return Err(RecoverableError::new(
                "approve_write: file writes are disabled for this project",
            )
            .into());
        }

        let resolved = crate::util::path_security::validate_approve_path(raw, &root, &security)
            .map_err(|e| RecoverableError::new(e.to_string()))?;

        ctx.agent.add_session_write_root(resolved.clone()).await;

        Ok(json!({
            "approved": resolved.to_string_lossy(),
            "scope": "this session only"
        }))
    }
}