agentd 0.1.2

Agent daemon for secure capability execution with pluggable isolation backends
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
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use anyhow::{Context, Result};
use async_trait::async_trait;
use serde::Deserialize;
use serde_json::Value;
use std::path::{Component, Path, PathBuf};
use std::time::{Duration, Instant};
use tokio::process::Command;
use tracing::{debug, info};

use super::{ExecContext, ExecutionResult, OutputSink, Runner};
use smith_protocol::ExecutionStatus;

#[derive(Debug, Deserialize)]
struct ValidationConfig {
    #[serde(default = "default_command")]
    command: Vec<String>,
    #[serde(default)]
    working_dir: Option<String>,
    #[serde(default)]
    timeout_ms: Option<u64>,
    #[serde(default)]
    env: Vec<EnvVar>,
}

#[derive(Debug, Deserialize)]
struct EnvVar {
    key: String,
    value: String,
}

fn default_command() -> Vec<String> {
    vec![
        "cargo".to_string(),
        "test".to_string(),
        "--workspace".to_string(),
        "--quiet".to_string(),
    ]
}

pub struct ValidationTestRunner;

impl ValidationTestRunner {
    pub fn new() -> Self {
        Self
    }

    fn parse_config(params: &Value) -> Result<ValidationConfig> {
        serde_json::from_value(params.clone()).context("Failed to parse validation parameters")
    }

    fn resolve_working_dir(ctx: &ExecContext, dir: Option<String>) -> Result<PathBuf> {
        let Some(dir) = dir else {
            return Ok(ctx.workdir.clone());
        };

        let rel = PathBuf::from(&dir);
        if rel.is_absolute() {
            anyhow::bail!("Validation working_dir must be relative: {}", dir);
        }

        for component in rel.components() {
            if matches!(component, Component::ParentDir) {
                anyhow::bail!(
                    "Validation working_dir may not traverse parent directories: {}",
                    dir
                );
            }
        }

        Ok(ctx.workdir.join(rel))
    }
}

#[async_trait]
impl Runner for ValidationTestRunner {
    fn digest(&self) -> String {
        "validation-test-runner-v1".to_string()
    }

    fn validate_params(&self, params: &Value) -> Result<()> {
        let config = Self::parse_config(params)?;
        if config.command.is_empty() {
            anyhow::bail!("Validation runner requires a non-empty command");
        }
        Ok(())
    }

    async fn execute(
        &self,
        ctx: &ExecContext,
        params: Value,
        out: &mut dyn OutputSink,
    ) -> Result<ExecutionResult> {
        let start = Instant::now();
        let config = Self::parse_config(&params)?;
        let working_dir = Self::resolve_working_dir(ctx, config.working_dir)?;
        let timeout_ms = config.timeout_ms.unwrap_or(300_000);

        if config.command.is_empty() {
            anyhow::bail!("Validation command may not be empty");
        }

        let mut command = Command::new(&config.command[0]);
        command.args(&config.command[1..]);
        command.current_dir(&working_dir);

        for env_var in config.env {
            command.env(env_var.key, env_var.value);
        }

        info!(
            program = %config.command[0],
            args = ?&config.command[1..],
            dir = %working_dir.display(),
            "Running validation command"
        );

        let output = tokio::time::timeout(Duration::from_millis(timeout_ms), command.output())
            .await
            .map_err(|_| anyhow::anyhow!("Validation command timed out after {}ms", timeout_ms))?
            .context("Failed to execute validation command")?;

        if !output.stdout.is_empty() {
            out.write_stdout(&output.stdout)?;
        }
        if !output.stderr.is_empty() {
            out.write_stderr(&output.stderr)?;
        }

        let duration_ms = start.elapsed().as_millis() as u64;
        debug!("validation runner completed in {}ms", duration_ms);

        let status = if output.status.success() {
            ExecutionStatus::Success
        } else {
            ExecutionStatus::Failed
        };

        Ok(ExecutionResult {
            status,
            exit_code: output.status.code(),
            artifacts: Vec::new(),
            duration_ms,
            stdout_bytes: output.stdout.len() as u64,
            stderr_bytes: output.stderr.len() as u64,
        })
    }
}