embacle 0.38.0

// ABOUTME: Environment sandboxing and tool policy for CLI subprocesses
// ABOUTME: Clears environment, whitelists keys, and sets working directory
//
// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 dravr.ai

use std::env;
use std::io;
use std::path::PathBuf;

use tokio::process::Command;
use tracing::debug;

use crate::config::{default_allowed_env_keys, RunnerConfig};

/// Policy controlling the subprocess execution environment
#[derive(Debug, Clone)]
pub struct SandboxPolicy {
    /// Environment variable keys to pass through from the host
    pub allowed_env_keys: Vec<String>,
    /// Working directory for the subprocess
    pub working_directory: PathBuf,
    /// Variables set explicitly after the allowlist, from
    /// [`RunnerConfig::env`]: a runner's own credential, never the host's.
    pub env_overrides: Vec<(String, String)>,
}

impl SandboxPolicy {
    /// Create a policy with defaults (standard env keys, current directory)
    #[must_use]
    pub fn new(working_directory: PathBuf) -> Self {
        Self {
            allowed_env_keys: default_allowed_env_keys(),
            working_directory,
            env_overrides: Vec::new(),
        }
    }

    /// Create a policy with custom allowed environment keys
    #[must_use]
    pub fn with_env_keys(mut self, keys: Vec<String>) -> Self {
        self.allowed_env_keys = keys;
        self
    }
}

/// Apply sandbox policy to a command before execution
///
/// This clears the subprocess environment, then re-injects only the
/// allowed keys from the host environment. The working directory is
/// also set according to the policy.
pub fn apply_sandbox(cmd: &mut Command, policy: &SandboxPolicy) {
    cmd.env_clear();

    let mut resolved = Vec::new();
    let mut missing = Vec::new();
    for key in &policy.allowed_env_keys {
        if let Ok(value) = env::var(key) {
            cmd.env(key, &value);
            resolved.push(key.as_str());
        } else {
            missing.push(key.as_str());
        }
    }

    for (key, value) in &policy.env_overrides {
        cmd.env(key, value);
    }

    cmd.current_dir(&policy.working_directory);

    debug!(
        cwd = %policy.working_directory.display(),
        resolved_count = resolved.len(),
        missing_count = missing.len(),
        ?missing,
        "Applied sandbox policy"
    );
}

/// Build a `SandboxPolicy` from a working directory path, falling back to
/// the current directory if the provided path does not exist.
///
/// # Errors
///
/// Returns an `io::Error` if neither the provided path nor the
/// current directory can be resolved.
pub fn build_policy(config: &RunnerConfig) -> io::Result<SandboxPolicy> {
    let dir = match config.working_directory.as_deref() {
        Some(p) if p.exists() => p.to_path_buf(),
        _ => env::current_dir()?,
    };
    let mut policy = SandboxPolicy::new(dir).with_env_keys(config.allowed_env_keys.clone());
    policy.env_overrides.clone_from(&config.env);
    Ok(policy)
}

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

    #[test]
    fn test_sandbox_policy_defaults() {
        let policy = SandboxPolicy::new(PathBuf::from("/tmp"));
        assert_eq!(policy.working_directory, PathBuf::from("/tmp"));
        assert!(!policy.allowed_env_keys.is_empty());
    }

    #[test]
    fn test_sandbox_policy_with_custom_keys() {
        let policy =
            SandboxPolicy::new(PathBuf::from("/tmp")).with_env_keys(vec!["CUSTOM_KEY".to_owned()]);
        assert_eq!(policy.allowed_env_keys, vec!["CUSTOM_KEY"]);
    }

    #[test]
    fn test_build_policy_fallback_to_cwd() {
        let keys = vec!["HOME".to_owned()];
        let policy = build_policy(
            &RunnerConfig::new(PathBuf::from("/bin/true")).with_allowed_env_keys(keys),
        )
        .unwrap(); // Safe: test assertion
                   // With None, should fall back to current directory
        assert_eq!(policy.working_directory, env::current_dir().unwrap()); // Safe: test assertion
    }

    #[test]
    fn test_build_policy_nonexistent_dir_falls_back() {
        let keys = vec!["HOME".to_owned()];
        let policy = build_policy(
            &RunnerConfig::new(PathBuf::from("/bin/true"))
                .with_allowed_env_keys(keys)
                .with_working_directory(PathBuf::from("/nonexistent/path/xyz123")),
        )
        .unwrap(); // Safe: test assertion
                   // Nonexistent path should fall back to cwd
        assert_eq!(policy.working_directory, env::current_dir().unwrap()); // Safe: test assertion
    }

    #[test]
    fn test_build_policy_existing_dir() {
        let keys = vec!["HOME".to_owned()];
        let dir = env::temp_dir();
        let policy = build_policy(
            &RunnerConfig::new(PathBuf::from("/bin/true"))
                .with_allowed_env_keys(keys)
                .with_working_directory(dir.clone()),
        )
        .unwrap(); // Safe: test assertion
        assert_eq!(policy.working_directory, dir);
        assert_eq!(policy.allowed_env_keys, vec!["HOME"]);
    }
}