shallguard 0.1.2

ShallGuard requirement traceability, executable coverage, and review tooling
Documentation
//! Isolated local model-provider process adapters.

use std::ffi::{OsStr, OsString};
use std::fs::File;
use std::io::Write as _;
use std::path::Path;
use std::process::{Command, ExitStatus, Stdio};
use std::thread;
use std::time::{Duration, Instant};

use anyhow::{Context, Result, bail};
use serde_json::Value;

use super::progress::{ProviderProgress, ReviewUnitProgress};
use super::{ProgressCallback, ReviewProvider, ReviewResult, millis};

pub(super) struct Invocation {
    pub(super) status: Option<ExitStatus>,
    pub(super) timed_out: bool,
    pub(super) stdout: String,
    pub(super) stderr: String,
    pub(super) response: Option<String>,
    pub(super) duration_ms: u64,
}

pub(super) struct ProviderInvocation<'a> {
    pub(super) provider: ReviewProvider,
    pub(super) model: Option<&'a str>,
    pub(super) local_provider: Option<&'a str>,
    pub(super) review_dir: &'a Path,
    pub(super) schema: &'a str,
    pub(super) timeout: Duration,
    pub(super) progress: Option<ProgressCallback>,
    pub(super) unit: ReviewUnitProgress<'a>,
}

#[derive(Debug, PartialEq, Eq)]
pub(super) struct CommandSpec {
    pub(super) executable: &'static str,
    pub(super) arguments: Vec<OsString>,
}

pub(super) fn invoke_provider(options: &ProviderInvocation<'_>) -> Result<Invocation> {
    let stdout_path = options.review_dir.join("provider.stdout");
    let stderr_path = options.review_dir.join("provider.stderr");
    let stdout = File::create(&stdout_path).context("creating provider stdout log")?;
    let stderr = File::create(&stderr_path).context("creating provider stderr log")?;
    let prompt_path = options.review_dir.join("prompt.txt");
    let copilot_stdin = if options.provider == ReviewProvider::Copilot {
        let prompt = std::fs::read_to_string(&prompt_path).context("reading provider prompt")?;
        Some(copilot_input(&prompt, options.schema))
    } else {
        None
    };
    let spec = command_spec(
        options.provider,
        options.model,
        options.local_provider,
        options.schema,
    );
    let mut command = Command::new(spec.executable);
    sanitize_provider_environment(&mut command);
    command
        .args(spec.arguments)
        .current_dir(options.review_dir)
        .stdout(Stdio::from(stdout))
        .stderr(Stdio::from(stderr));
    if options.provider == ReviewProvider::Copilot {
        command.stdin(Stdio::piped());
    } else {
        let stdin = File::open(&prompt_path).context("opening provider prompt")?;
        command.stdin(Stdio::from(stdin));
    }
    let mut child = command
        .spawn()
        .with_context(|| format!("starting {} CLI", options.provider.as_str()))?;
    if let Some(input) = copilot_stdin {
        let mut stdin = child
            .stdin
            .take()
            .context("opening Copilot standard input")?;
        if let Err(error) = stdin.write_all(input.as_bytes()) {
            let _ = child.kill();
            let _ = child.wait();
            return Err(error).context("writing Copilot prompt and response schema");
        }
    }
    let started = Instant::now();
    let mut provider_progress =
        ProviderProgress::new(options.progress, options.provider.as_str(), options.unit);
    let (status, timed_out) = loop {
        if let Some(status) = child.try_wait().context("waiting for provider CLI")? {
            break (Some(status), false);
        }
        let elapsed = started.elapsed();
        if elapsed >= options.timeout {
            child.kill().context("terminating timed-out provider CLI")?;
            let status = child.wait().context("reaping timed-out provider CLI")?;
            break (Some(status), true);
        }
        provider_progress.update(elapsed);
        thread::sleep(Duration::from_millis(100));
    };
    let stdout = std::fs::read_to_string(&stdout_path).context("reading provider stdout")?;
    let stderr = std::fs::read_to_string(&stderr_path).context("reading provider stderr")?;
    let response = match options.provider {
        ReviewProvider::Codex => {
            std::fs::read_to_string(options.review_dir.join("provider-response.json"))
                .ok()
                .or_else(|| (!stdout.trim().is_empty()).then(|| stdout.clone()))
        }
        ReviewProvider::Claude | ReviewProvider::Copilot => {
            (!stdout.trim().is_empty()).then(|| stdout.clone())
        }
    };
    Ok(Invocation {
        status,
        timed_out,
        stdout,
        stderr,
        response,
        duration_ms: millis(started.elapsed()),
    })
}

pub(super) fn copilot_input(prompt: &str, schema: &str) -> String {
    format!("{prompt}\n\nExact response JSON Schema:\n{schema}")
}

#[shallguard::enforces("REQ-REV-002", "REQ-REV-009", "REQ-SEC-003")]
fn sanitize_provider_environment(command: &mut Command) {
    command.env_clear();
    for (name, value) in std::env::vars_os() {
        if provider_environment_allowed(&name) {
            command.env(name, value);
        }
    }
}

pub(super) fn provider_environment_allowed(name: &OsStr) -> bool {
    let Some(name) = name.to_str() else {
        return false;
    };
    matches!(
        name,
        "PATH"
            | "HOME"
            | "USER"
            | "LOGNAME"
            | "SHELL"
            | "TMPDIR"
            | "XDG_CONFIG_HOME"
            | "XDG_CACHE_HOME"
            | "XDG_DATA_HOME"
            | "HTTP_PROXY"
            | "HTTPS_PROXY"
            | "ALL_PROXY"
            | "NO_PROXY"
            | "SSL_CERT_FILE"
            | "SSL_CERT_DIR"
            | "LANG"
            | "LC_ALL"
            | "TERM"
    ) || [
        "OPENAI_",
        "CODEX_",
        "ANTHROPIC_",
        "CLAUDE_",
        "COPILOT_",
        "OLLAMA_",
        "LMSTUDIO_",
        "LM_STUDIO_",
    ]
    .iter()
    .any(|prefix| name.starts_with(prefix))
}

#[shallguard::enforces("REQ-REV-001", "REQ-REV-002", "REQ-REV-009", "REQ-SEC-003")]
pub(super) fn command_spec(
    provider: ReviewProvider,
    model: Option<&str>,
    local_provider: Option<&str>,
    schema: &str,
) -> CommandSpec {
    let mut arguments = Vec::<OsString>::new();
    match provider {
        ReviewProvider::Codex => {
            arguments.extend(
                [
                    "exec",
                    "--ephemeral",
                    "--sandbox",
                    "read-only",
                    "--skip-git-repo-check",
                    "--ignore-rules",
                    "--output-schema",
                    "response-schema.json",
                    "--output-last-message",
                    "provider-response.json",
                ]
                .into_iter()
                .map(OsString::from),
            );
            if let Some(model) = model {
                arguments.extend([OsString::from("--model"), OsString::from(model)]);
            }
            if let Some(local_provider) = local_provider {
                arguments.extend([
                    OsString::from("--oss"),
                    OsString::from("--local-provider"),
                    OsString::from(local_provider),
                ]);
            }
            arguments.push(OsString::from("-"));
        }
        ReviewProvider::Claude => {
            arguments.extend(
                [
                    "--print",
                    "--bare",
                    "--safe-mode",
                    "--tools",
                    "",
                    "--no-session-persistence",
                    "--permission-mode",
                    "dontAsk",
                    "--output-format",
                    "json",
                    "--json-schema",
                ]
                .into_iter()
                .map(OsString::from),
            );
            arguments.push(OsString::from(schema));
            if let Some(model) = model {
                arguments.extend([OsString::from("--model"), OsString::from(model)]);
            }
        }
        ReviewProvider::Copilot => {
            arguments.extend(
                [
                    "--silent",
                    "--no-ask-user",
                    "--no-color",
                    "--no-custom-instructions",
                    "--no-remote",
                    "--no-remote-export",
                    "--disable-builtin-mcps",
                    "--deny-tool=shell",
                    "--deny-tool=write",
                    "--deny-tool=read",
                    "--deny-tool=url",
                    "--deny-tool=memory",
                ]
                .into_iter()
                .map(OsString::from),
            );
            if let Some(model) = model {
                arguments.extend([OsString::from("--model"), OsString::from(model)]);
            }
        }
    }
    CommandSpec {
        executable: provider.executable(),
        arguments,
    }
}

pub(super) fn provider_version(provider: ReviewProvider) -> Result<String> {
    let output = Command::new(provider.executable())
        .arg("--version")
        .output()
        .with_context(|| {
            format!(
                "{} CLI is not installed or not available on PATH",
                provider.as_str()
            )
        })?;
    if !output.status.success() {
        bail!(
            "{} --version failed with {}",
            provider.as_str(),
            output.status
        );
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    let version = if stdout.trim().is_empty() {
        stderr.trim()
    } else {
        stdout.trim()
    };
    if version.is_empty() {
        bail!("{} --version returned no version", provider.as_str());
    }
    Ok(version.to_string())
}

pub(super) fn parse_provider_response(
    provider: ReviewProvider,
    text: &str,
) -> Result<ReviewResult> {
    let value: Value = serde_json::from_str(text).context("parsing provider JSON")?;
    let structured = match provider {
        ReviewProvider::Codex | ReviewProvider::Copilot => value,
        ReviewProvider::Claude => {
            if let Some(value) = value.get("structured_output") {
                value.clone()
            } else if let Some(result) = value.get("result").and_then(Value::as_str) {
                serde_json::from_str(result).context("parsing Claude result JSON")?
            } else {
                value
            }
        }
    };
    serde_json::from_value(structured).context("decoding structured review response")
}