tuls 0.1.4

A compact Rust MCP toolbox for filesystem access, HTTP fetches, persistent memory, local process execution, reusable skills, and provider-backed local subagents.
use super::*;
use tempfile::tempdir;

fn server() -> ShellServer {
    let temp = tempdir().unwrap();
    let access = AccessControl::from_args(&[temp.keep()]).unwrap();
    ShellServer::new(
        access,
        ToolPolicy::from_selectors(&[], &[], TOOL_SPECS).unwrap(),
    )
}

#[test]
fn server_advertises_tasks_and_only_the_command_tool() {
    let server = server();
    let info = server.get_info();
    assert!(info.capabilities.supports_tasks());
    assert!(info.capabilities.tools.is_some());
    let tools = server.tools();
    assert_eq!(tools.len(), 1);
    assert_eq!(tools[0].name, "execute_command");
    assert!(
        tools[0]
            .description
            .as_deref()
            .unwrap()
            .contains("MCP Task")
    );
}

#[test]
fn semantic_argument_errors_are_tool_errors() {
    let empty = ExecuteCommandArgs {
        program: "   ".into(),
        args: Vec::new(),
        cwd: None,
        timeout_ms: DEFAULT_TIMEOUT_MS,
    };
    assert_eq!(
        ShellServer::validate_arguments(&empty).unwrap().is_error,
        Some(true)
    );

    let out_of_range = ExecuteCommandArgs {
        program: "echo".into(),
        args: Vec::new(),
        cwd: None,
        timeout_ms: MAX_TIMEOUT_MS + 1,
    };
    assert_eq!(
        ShellServer::validate_arguments(&out_of_range)
            .unwrap()
            .is_error,
        Some(true)
    );
}

#[tokio::test]
async fn command_tasks_advertise_the_shared_poll_interval() {
    let server = server();
    let args = ExecuteCommandArgs {
        program: "true".into(),
        args: Vec::new(),
        cwd: None,
        timeout_ms: 1000,
    };
    let CallToolResponse::Task(task) = server.start_task(args) else {
        panic!("expected a task handle");
    };
    assert_eq!(
        task.task.poll_interval_ms,
        Some(DEFAULT_TASK_POLL_INTERVAL_MS)
    );
}

#[test]
fn task_ttl_exceeds_command_execution_limit() {
    assert_eq!(task_ttl_ms(1), TASK_TTL_MARGIN_MS + 1);
    assert_eq!(
        task_ttl_ms(MAX_TIMEOUT_MS),
        MAX_TIMEOUT_MS + TASK_TTL_MARGIN_MS
    );
}

#[test]
fn summary_text_reports_exit_code() {
    let output = CommandOutput {
        exit_code: Some(0),
        stdout: "out".to_string(),
        stderr: String::new(),
        timed_out: false,
        stdout_truncated: false,
        stderr_truncated: false,
    };
    let text = ShellServer::summary_text(&output);
    assert!(text.contains("exit code: 0"));
    assert!(text.contains("stdout (full): out"));
}

#[test]
fn summary_text_reports_timeout_and_truncation() {
    let output = CommandOutput {
        exit_code: None,
        stdout: "x".repeat(5000),
        stderr: String::new(),
        timed_out: true,
        stdout_truncated: true,
        stderr_truncated: false,
    };
    let text = ShellServer::summary_text(&output);
    assert!(text.contains("timed out"));
    assert!(text.contains("stdout (truncated at 8 KiB)"));
    assert!(text.contains('…'));
    assert!(!text.contains("exit code"));
}

#[test]
fn preview_keeps_short_text_intact() {
    assert_eq!(preview("short"), "short");
    let long = "a".repeat(5000);
    let preview = preview(&long);
    assert_eq!(preview.chars().count(), 4001);
    assert!(preview.ends_with('…'));
}

#[test]
fn sanitize_stream_replaces_binary_controls() {
    assert_eq!(sanitize_stream("a\0b\n"), "a b\n");
}

#[test]
fn command_output_is_structured_and_bounded() {
    let output = CommandOutput {
        exit_code: Some(0),
        stdout: "out".into(),
        stderr: String::new(),
        timed_out: false,
        stdout_truncated: false,
        stderr_truncated: false,
    };
    let result = render_output(output).unwrap();
    assert_eq!(result.structured_content.as_ref().unwrap()["exitCode"], 0);
    assert!(!result.is_error.unwrap_or(false));
}