agentd 0.1.1

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

//! Simple integration test for planner exec runner

use anyhow::{Context, Result};
use serde_json::json;
use std::time::Instant;
use tempfile::TempDir;
use tracing::{debug, info};

use agentd::runners::planner_exec::PlannerExecRunner;
use agentd::runners::{
    create_exec_context, ExecContext, ExecutionResult, MemoryOutputSink, Runner, Scope,
};
use agentd::ExecutionLimits;
use smith_protocol::ExecutionStatus;

/// Test fixture for planner integration tests
struct PlannerTestFixture {
    temp_dir: TempDir,
    runner: PlannerExecRunner,
}

impl PlannerTestFixture {
    /// Create a new test fixture
    fn new() -> Result<Self> {
        let temp_dir = TempDir::new().context("Failed to create temp directory")?;
        let runner = PlannerExecRunner::new();

        Ok(Self { temp_dir, runner })
    }

    /// Create a test execution context
    fn create_exec_context(&self) -> ExecContext {
        let limits = ExecutionLimits {
            cpu_ms_per_100ms: 50,
            mem_bytes: 100_000_000,
            io_bytes: 10_000_000,
            pids_max: 10,
            timeout_ms: 30_000,
        };

        let scope = Scope {
            paths: vec![self.temp_dir.path().to_string_lossy().to_string()],
            urls: vec![],
        };

        create_exec_context(
            self.temp_dir.path(),
            limits,
            scope,
            "test-trace-id".to_string(),
        )
    }

    /// Create test parameters as JSON
    fn create_test_params(&self, goal: &str) -> serde_json::Value {
        json!({
            "workflow_id": "test-workflow-123",
            "goal": goal,
            "workflow_type": "simple",
            "max_steps": 5,
            "timeout_ms": 30000
        })
    }
}

#[tokio::test]
async fn test_planner_exec_basic_execution() -> Result<()> {
    let fixture = PlannerTestFixture::new()?;

    info!("Starting basic planner execution test");

    let params = fixture.create_test_params("Test simple workflow execution");
    let ctx = fixture.create_exec_context();
    let mut output = MemoryOutputSink::new();

    let start = Instant::now();
    let result = fixture.runner.execute(&ctx, params, &mut output).await?;
    let duration = start.elapsed();

    info!("Planner execution completed in {:?}", duration);
    debug!("Execution result: {:?}", result);

    // Verify basic execution properties
    assert!(matches!(
        result.status,
        ExecutionStatus::Ok | ExecutionStatus::Error
    ));
    assert!(result.duration_ms > 0);

    // Check that some output was generated
    let has_output =
        !output.stdout.is_empty() || !output.stderr.is_empty() || !output.logs.is_empty();
    debug!(
        "Output check - stdout: {} bytes, stderr: {} bytes, logs: {} entries",
        output.stdout.len(),
        output.stderr.len(),
        output.logs.len()
    );

    info!("Basic planner execution test passed");
    Ok(())
}

#[tokio::test]
async fn test_planner_exec_error_handling() -> Result<()> {
    let fixture = PlannerTestFixture::new()?;

    info!("Testing planner error handling");

    // Create parameters that might cause errors
    let params = json!({
        "workflow_id": "test-error-workflow",
        "goal": "This is an intentionally invalid goal to test error handling",
        "workflow_type": "invalid_type",
        "max_steps": 0, // Invalid
        "timeout_ms": 1 // Very short timeout
    });

    let ctx = fixture.create_exec_context();
    let mut output = MemoryOutputSink::new();

    let result = fixture.runner.execute(&ctx, params, &mut output).await;

    // Should either succeed with error status or return an error
    match result {
        Ok(exec_result) => {
            info!("Execution completed with status: {:?}", exec_result.status);
            // Allow any status - we're just testing that it doesn't panic
        }
        Err(e) => {
            info!("Execution failed as expected: {}", e);
            // This is also acceptable for error handling test
        }
    }

    info!("Error handling test completed");
    Ok(())
}