Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

31.0 KB
Raw Blame
use super::*;
use std::{collections::BTreeMap, sync::Arc, time::Duration};
use tokio::{
    io::AsyncReadExt,
    net::{TcpListener, TcpStream},
};

// Real-runtime tests are opt-in; CI and local validation also run --ignored.
async fn setup(limits: Limits) -> (tempfile::TempDir, ExecutionService) {
    let root = tempfile::tempdir().unwrap();
    let binary = Command::new("which").arg("deno").output().await.unwrap();
    assert!(binary.status.success(), "Deno 2.9.6 must be on PATH");
    let binary = PathBuf::from(String::from_utf8(binary.stdout).unwrap().trim());
    let runner = DenoRunner::new(binary, root.path().to_owned(), 128)
        .await
        .unwrap();
    (
        root,
        ExecutionService::new(Arc::new(runner), limits).unwrap(),
    )
}

async fn collect(mut handle: ExecutionHandle) -> (Vec<ExecutionEvent>, Outcome) {
    let mut events = Vec::new();
    loop {
        let event = tokio::time::timeout(Duration::from_secs(10), handle.events.recv())
            .await
            .unwrap()
            .unwrap();
        if let EventKind::Finished { outcome } = event.kind {
            return (events, outcome);
        }
        events.push(event);
    }
}

async fn run(
    service: &ExecutionService,
    source: &str,
    timeout_ms: u64,
) -> (Vec<ExecutionEvent>, Outcome) {
    collect(
        service
            .execute(
                ExecuteRequest {
                    source: source.into(),
                    timeout_ms,
                },
                RunEnvironment::default(),
            )
            .unwrap(),
    )
    .await
}

async fn read_request(stream: &mut TcpStream) -> String {
    let mut bytes = Vec::new();
    loop {
        let mut buffer = [0; 4096];
        let count = stream.read(&mut buffer).await.unwrap();
        assert_ne!(count, 0);
        bytes.extend_from_slice(&buffer[..count]);
        if let Some(end) = bytes.windows(4).position(|window| window == b"\r\n\r\n") {
            let headers = String::from_utf8_lossy(&bytes[..end]);
            let length = headers
                .lines()
                .find_map(|line| {
                    let (name, value) = line.split_once(':')?;
                    name.eq_ignore_ascii_case("content-length")
                        .then(|| value.trim().parse::<usize>().unwrap())
                })
                .unwrap_or_default();
            if bytes.len() >= end + 4 + length {
                break;
            }
        }
    }
    String::from_utf8(bytes).unwrap()
}

async fn respond(stream: &mut TcpStream, body: &str) {
    let response = format!(
        "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
        body.len()
    );
    stream.write_all(response.as_bytes()).await.unwrap();
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn real_sdk_nested_calls_are_authenticated_and_concurrent() {
    let (_root, service) = setup(Limits {
        max_output_bytes: 1024,
        max_frame_bytes: 1024,
        max_result_bytes: 512,
        ..Limits::default()
    })
    .await;
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server =
        tokio::spawn(async move {
            let (mut first, _) = listener.accept().await.unwrap();
            let first_request = read_request(&mut first).await;
            // Neither request can finish until both have arrived: proves actual HTTP concurrency.
            let (mut second, _) = listener.accept().await.unwrap();
            let second_request = read_request(&mut second).await;
            for request in [&first_request, &second_request] {
                assert!(request.contains(
                    "traceparent: 00-01234567890123456789012345678901-0123456789012345-01"
                ));
                assert!(request.starts_with("POST /decisions "), "{request}");
                assert!(
                    request
                        .to_ascii_lowercase()
                        .contains("x-macro-code-execution: 1\r\n"),
                    "{request}"
                );
                assert!(
                    request
                        .to_ascii_lowercase()
                        .contains("authorization: bearer fixture-run-token\r\n")
                );
            }
            respond(&mut second, r#"{"probabilities":{"yes":0.2}}"#).await;
            respond(&mut first, r#"{"probabilities":{"yes":0.8}}"#).await;
        });
    let environment = RunEnvironment {
        token: "fixture-run-token".into(),
        trace_headers: BTreeMap::from([(
            "traceparent".into(),
            "00-01234567890123456789012345678901-0123456789012345-01".into(),
        )]),
        session_id: Some(uuid::Uuid::from_u128(1)),
        execution_id: Some(uuid::Uuid::from_u128(2)),
        hosts: BTreeMap::from([("cognition".into(), format!("http://{address}"))]),
        unattended: None,
    };
    let source = r#"
import { Macro } from '@macro-inc/sdk';
import Handlebars from 'handlebars';
export async function main({token, hosts, macro: supplied, session, execution}) {
  if (!(supplied instanceof Macro) || session.id !== "00000000-0000-0000-0000-000000000001" || execution.id !== "00000000-0000-0000-0000-000000000002") throw new Error("Missing SDK handles");
  const macro = new Macro({token, hosts});
  console.log('x'.repeat(650));
  const values = await Promise.all(['one', 'two'].map(input => macro.ai.decide({input, questions: {yes: 'Is this relevant?'}})));
  const document = macro.documents.byId('fixture-document');
  return { data: { text: Handlebars.compile('{{name}}: {{count}}')({name: document.id, count: values.length}), sum: values.reduce((sum, result) => sum + result.probabilities.yes, 0) }, reviews: [] };
}
"#;
    let (events, outcome) = collect(
        service
            .execute(
                ExecuteRequest {
                    source: source.into(),
                    timeout_ms: 5000,
                },
                environment,
            )
            .unwrap(),
    )
    .await;
    assert!(
        matches!(outcome, Outcome::Succeeded { ref value } if value["data"]["text"] == "fixture-document: 2" && value["data"]["sum"] == 1.0),
        "{outcome:?}"
    );
    let progress: Vec<_> = events
        .iter()
        .filter_map(|event| match &event.kind {
            EventKind::Progress { value } => Some(value),
            _ => None,
        })
        .collect();
    assert_eq!(progress.len(), 4);
    assert_eq!(
        progress
            .iter()
            .filter(|event| event["status"] == "started")
            .count(),
        2
    );
    assert_eq!(
        progress
            .iter()
            .filter(|event| event["status"] == "completed")
            .count(),
        2
    );
    assert!(
        progress
            .iter()
            .all(|event| event["service"] == "cognition" && event["operation"] == "decisions")
    );
    tokio::time::timeout(Duration::from_secs(5), server)
        .await
        .unwrap()
        .unwrap();
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_program_presents_a_view_through_its_session() {
    let (_root, service) = setup(Limits::default()).await;
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let request = read_request(&mut stream).await;
        let response = "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n";
        stream.write_all(response.as_bytes()).await.unwrap();
        request
    });
    let environment = RunEnvironment {
        token: "fixture-run-token".into(),
        trace_headers: BTreeMap::new(),
        session_id: Some(uuid::Uuid::from_u128(1)),
        execution_id: Some(uuid::Uuid::from_u128(2)),
        hosts: BTreeMap::from([("agent-harness".into(), format!("http://{address}"))]),
        unattended: None,
    };
    let source = r#"
export async function main({execution}) {
  await execution.views.present({ title: 'Launch notes', widgets: [{ type: 'md', markdown: 'Shipped.' }] });
  return { data: 'presented' };
}
"#;
    let (_, outcome) = collect(
        service
            .execute(
                ExecuteRequest {
                    source: source.into(),
                    timeout_ms: 5000,
                },
                environment,
            )
            .unwrap(),
    )
    .await;
    assert!(
        matches!(outcome, Outcome::Succeeded { ref value } if value["data"] == "presented"),
        "{outcome:?}"
    );
    let request = tokio::time::timeout(Duration::from_secs(5), server)
        .await
        .unwrap()
        .unwrap();
    assert!(
        request.starts_with("POST /agent-sessions/00000000-0000-0000-0000-000000000001/views "),
        "{request}"
    );
    let body = request.split("\r\n\r\n").nth(1).unwrap();
    let body: serde_json::Value = serde_json::from_str(body).unwrap();
    assert_eq!(body["view"]["title"], "Launch notes");
    assert_eq!(body["executionId"], "00000000-0000-0000-0000-000000000002");
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn javascript_logs_result_and_cleanup() {
    let (root, service) = setup(Limits::default()).await;
    let (events, outcome) = run(&service, "export async function main() { console.log('working'); await Promise.resolve(); return 6 * 7; }", 5000).await;
    assert!(matches!(outcome, Outcome::Succeeded { value } if value == 42));
    assert!(events.iter().any(
        |event| matches!(&event.kind, EventKind::Log { message, .. } if message == "working")
    ));
    assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn requires_javascript_exported_main() {
    let (_root, service) = setup(Limits::default()).await;
    for source in [
        "return 42;",
        "export const main = 42;",
        "export function main() { const n: number = 42; return n; }",
    ] {
        let (_, outcome) = run(&service, source, 5000).await;
        assert!(matches!(outcome, Outcome::Failed { error } if error.code == FailureCode::Runtime));
    }
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn denies_ambient_io_and_external_module_imports() {
    let (_root, service) = setup(Limits::default()).await;
    let outside = tempfile::tempdir().unwrap();
    let module = outside.path().join("outside.mjs");
    let json = outside.path().join("outside.json");
    tokio::fs::write(&json, r#"{"secret":"fixture-only"}"#)
        .await
        .unwrap();
    tokio::fs::write(&module, "export default 42;")
        .await
        .unwrap();
    let bodies = [
        "return Deno.env.get('PATH');".to_owned(),
        "return Deno.readTextFile('/etc/passwd');".into(),
        "await Deno.writeTextFile('/tmp/macro-code-execution-forbidden', 'bad');".into(),
        "return new Deno.Command('/bin/true').output();".into(),
        format!("return await import('{}');", module.display()),
        format!(
            "return await import('{}', {{with: {{type: 'json'}}}});",
            json.display()
        ),
        format!(
            "const path = '{}'; return await import(path);",
            module.display()
        ),
        format!(
            "const worker = new Worker('file://{}', {{type: 'module'}}); await new Promise((resolve, reject) => {{ worker.onmessage = resolve; worker.onerror = reject; }});",
            module.display()
        ),
        "const fs = await import('node:fs'); return fs.readFileSync('/etc/passwd', 'utf8');".into(),
        "return await import('https://example.com/module.js');".into(),
        "return await import('npm:lodash');".into(),
    ];
    for body in bodies {
        let source = format!("export async function main() {{ {body} }}");
        let (_, outcome) = run(&service, &source, 5000).await;
        assert!(
            matches!(outcome, Outcome::Failed { .. }),
            "allowed forbidden source: {source}"
        );
    }
    let source = format!(
        "import value from '{}'; export function main() {{ return value; }}",
        module.display()
    );
    let (_, outcome) = run(&service, &source, 5000).await;
    assert!(
        matches!(outcome, Outcome::Failed { .. }),
        "static import escaped scratch: {outcome:?}"
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn rejects_sleeping_and_points_at_routines() {
    let (_root, service) = setup(Limits::default()).await;
    let sources = [
        "export async function main() { await new Promise(resolve => setTimeout(resolve, 20000)); }",
        "export function main() { setInterval(() => {}, 1000); }",
        "export function main() { setImmediate(() => {}); }",
        "export async function main() { await new Promise(resolve => AbortSignal.timeout(1000).addEventListener('abort', resolve)); }",
        "export function main() { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000); }",
        "export async function main() { await Atomics.waitAsync(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 1000).value; }",
        "export function main() { new Worker('data:text/javascript,setTimeout(() => postMessage(1), 1000)', {type: 'module'}); }",
        "export async function main() { const { setTimeout } = await import('node:timers/promises'); await setTimeout(1000); }",
        "import { setTimeout } from 'node:timers'; export async function main() { await new Promise(resolve => setTimeout(resolve, 1000)); }",
        "import { Worker } from 'worker_threads'; export function main() { return Worker; }",
    ];
    for source in sources {
        let (_, outcome) = run(&service, source, 5000).await;
        assert!(
            matches!(&outcome, Outcome::Failed { error } if error.code == FailureCode::Runtime && error.message.contains("create a routine with macro.routines.create")),
            "{source}: {outcome:?}"
        );
    }
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn denies_unlisted_destinations_including_redirects() {
    let (_root, service) = setup(Limits::default()).await;
    let forbidden = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let forbidden_address = forbidden.local_addr().unwrap();
    let (_, outcome) = run(
        &service,
        &format!(
            "export async function main() {{ return await fetch('http://{forbidden_address}'); }}"
        ),
        5000,
    )
    .await;
    assert!(matches!(outcome, Outcome::Failed { .. }));
    let allowed = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let allowed_address = allowed.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (mut stream, _) = allowed.accept().await.unwrap();
        read_request(&mut stream).await;
        stream.write_all(format!("HTTP/1.1 302 Found\r\nLocation: http://{forbidden_address}\r\nContent-Length: 0\r\nConnection: close\r\n\r\n").as_bytes()).await.unwrap();
    });
    let (_, outcome) = collect(service.execute(ExecuteRequest { source: format!("export async function main() {{ return await fetch('http://{allowed_address}'); }}"), timeout_ms: 5000 }, RunEnvironment { hosts: BTreeMap::from([("cognition".into(), format!("http://{allowed_address}"))]), ..RunEnvironment::default() }).unwrap()).await;
    assert!(
        matches!(outcome, Outcome::Failed { .. }),
        "redirect escaped allowlist: {outcome:?}"
    );
    tokio::time::timeout(Duration::from_secs(5), server)
        .await
        .unwrap()
        .unwrap();
    assert!(
        tokio::time::timeout(Duration::from_millis(50), forbidden.accept())
            .await
            .is_err()
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn times_out_cancels_and_reaps_busy_processes() {
    let (root, service) = setup(Limits::default()).await;
    let (_, outcome) = run(&service, "export function main() { while (true) {} }", 300).await;
    assert!(matches!(outcome, Outcome::TimedOut));
    let mut handle = service
        .execute(
            ExecuteRequest {
                source: "export function main() { console.log('ready'); while(true) {} }".into(),
                timeout_ms: 5000,
            },
            RunEnvironment::default(),
        )
        .unwrap();
    while !matches!(
        handle.events.recv().await.unwrap().kind,
        EventKind::Log { .. }
    ) {}
    handle.cancellation.cancel();
    let (_, outcome) = collect(handle).await;
    assert!(matches!(outcome, Outcome::Cancelled));
    assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn bounds_output_and_rejects_invalid_or_duplicate_frames() {
    let (_root, service) = setup(Limits {
        max_frame_bytes: 16 * 1024,
        max_result_bytes: 8 * 1024,
        ..Limits::default()
    })
    .await;
    for body in [
        "console.log('x'.repeat(20000));",
        "Deno.stderr.writeSync(new TextEncoder().encode('x'.repeat(20000)));",
        "while (true) console.log('spam');",
        "Deno.stdout.writeSync(new TextEncoder().encode('not json\\n'));",
        "Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"started\"}\\n'));",
        "Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"result\",\"value\":1}\\n')); return 2;",
    ] {
        let (_, outcome) = run(
            &service,
            &format!("export function main() {{ {body} }}"),
            5000,
        )
        .await;
        assert!(
            matches!(outcome, Outcome::Failed { ref error } if matches!(error.code, FailureCode::Limit | FailureCode::Protocol)),
            "{body}: {outcome:?}"
        );
    }
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn result_at_the_limit_fits_its_frame_unsummarized() {
    let (_root, service) = setup(Limits {
        max_frame_bytes: 1024,
        max_output_bytes: 4096,
        max_result_bytes: 1024 - RESULT_FRAME_OVERHEAD,
        ..Limits::default()
    })
    .await;
    // JSON quotes bring the string to exactly max_result_bytes.
    let (_, outcome) = run(
        &service,
        &format!(
            "export function main() {{ return 'x'.repeat({}); }}",
            1024 - RESULT_FRAME_OVERHEAD - 2
        ),
        5000,
    )
    .await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(
        value.as_str().unwrap().len(),
        1024 - RESULT_FRAME_OVERHEAD - 2
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn oversized_result_data_is_summarized_and_reviews_kept() {
    let limits = Limits::default();
    let max_result_bytes = limits.max_result_bytes;
    let (_root, service) = setup(limits).await;
    let (_, outcome) = run(
        &service,
        "export function main(context) { return {data: {keys: Object.keys(context), items: Array.from({length: 2000}, (_, id) => ({id, name: 'x'.repeat(100)}))}, reviews: []}; }",
        5000,
    )
    .await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(value["reviews"], serde_json::json!([]));
    let data = &value["data"];
    assert_eq!(data["truncated"], true);
    assert_eq!(data["limitBytes"], max_result_bytes);
    assert!(data["bytes"].as_u64().unwrap() > max_result_bytes as u64);
    assert_eq!(
        data["outline"],
        "{keys: Array(8) of string, items: Array(2000) of {id: number, name: string}}"
    );
    assert!(data["preview"].as_str().unwrap().starts_with(
        r#"{"keys":["token","traceHeaders","sessionId","executionId","hosts","macro","session","execution"],"items":[{"id":0,"#
    ));
    assert!(serde_json::to_vec(&value).unwrap().len() <= max_result_bytes);
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn printed_result_cannot_complete_before_process_exit() {
    let (root, service) = setup(Limits::default()).await;
    let (_, outcome) = run(&service, "export function main() { Deno.stdout.writeSync(new TextEncoder().encode('{\"type\":\"result\",\"value\":42}\\n')); while(true) {} }", 300).await;
    assert!(matches!(outcome, Outcome::TimedOut));
    assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn dropping_receiver_and_shutdown_reap_processes() {
    let (root, service) = setup(Limits::default()).await;
    let mut handle = service
        .execute(
            ExecuteRequest {
                source: "export function main() { console.log('ready'); while(true) {} }".into(),
                timeout_ms: 5000,
            },
            RunEnvironment::default(),
        )
        .unwrap();
    while !matches!(
        handle.events.recv().await.unwrap().kind,
        EventKind::Log { .. }
    ) {}
    drop(handle);
    service.shutdown().await;
    assert_eq!(std::fs::read_dir(root.path()).unwrap().count(), 0);
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn total_output_budget_applies_across_small_frames() {
    let (_root, service) = setup(Limits {
        max_frame_bytes: 1024,
        max_output_bytes: 4096,
        max_result_bytes: 512,
        ..Limits::default()
    })
    .await;
    let (_, outcome) = run(&service, "export async function main() { for(let i = 0; i < 20; i++) { console.log('x'.repeat(500)); } return null; }", 5000).await;
    assert!(
        matches!(outcome, Outcome::Failed { error } if error.code == FailureCode::Limit && error.message == "process output limit exceeded")
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn redacts_run_token_from_results_keys_console_stderr_and_errors() {
    let (_root, service) = setup(Limits::default()).await;
    let token = "fixture-secret-token";
    for source in [
        "export function main({token}) { console.log(token); Deno.stderr.writeSync(new TextEncoder().encode(token + '\\n')); return {[token]: token, embedded: 'Bearer ' + token}; }",
        "export function main({token}) { throw new Error('token ' + token); }",
    ] {
        let (events, outcome) = collect(
            service
                .execute(
                    ExecuteRequest {
                        source: source.into(),
                        timeout_ms: 5000,
                    },
                    RunEnvironment {
                        token: token.into(),
                        ..RunEnvironment::default()
                    },
                )
                .unwrap(),
        )
        .await;
        let serialized = serde_json::to_string(&(events, &outcome)).unwrap();
        assert!(
            !serialized.contains(token),
            "run credential escaped redaction"
        );
        assert!(serialized.contains("[REDACTED]"));
        match outcome {
            Outcome::Succeeded { value } => {
                assert_eq!(value["[REDACTED]"], "[REDACTED]");
                assert_eq!(value["embedded"], "Bearer [REDACTED]");
            }
            Outcome::Failed { error } => assert_eq!(error.message, "Error: token [REDACTED]"),
            unexpected => panic!("unexpected outcome: {unexpected:?}"),
        }
    }
    service.shutdown().await;
}

fn unattended(
    token: &str,
    hosts: &[(&str, String)],
    arguments: serde_json::Value,
    dry_run: bool,
) -> RunEnvironment {
    RunEnvironment {
        token: token.into(),
        hosts: hosts
            .iter()
            .map(|(name, url)| ((*name).to_owned(), url.clone()))
            .collect(),
        unattended: Some(Unattended {
            arguments: arguments.as_object().unwrap().clone(),
            dry_run,
        }),
        ..RunEnvironment::default()
    }
}

async fn run_unattended(
    service: &ExecutionService,
    source: &str,
    environment: RunEnvironment,
) -> (Vec<serde_json::Value>, Outcome) {
    let (events, outcome) = collect(
        service
            .execute(
                ExecuteRequest {
                    source: source.into(),
                    timeout_ms: 10_000,
                },
                environment,
            )
            .unwrap(),
    )
    .await;
    let progress = events
        .into_iter()
        .filter_map(|event| match event.kind {
            EventKind::Progress { value } => Some(value),
            _ => None,
        })
        .collect();
    (progress, outcome)
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn an_unattended_result_is_kept_whole_or_fails_over_the_limit() {
    let (_root, service) = setup(Limits::default()).await;
    let fits = "export function main() { return { items: Array.from({ length: 400 }, (_, id) => ({ id, name: 'x'.repeat(100) })) }; }";
    let (_, outcome) = run_unattended(
        &service,
        fits,
        unattended("fixture-run-token", &[], serde_json::json!({}), true),
    )
    .await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(value["items"].as_array().unwrap().len(), 400);

    let (_, outcome) = run_unattended(
        &service,
        "export function main() { return 'x'.repeat(70 * 1024); }",
        unattended("fixture-run-token", &[], serde_json::json!({}), true),
    )
    .await;
    let Outcome::Failed { error } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(
        error.message,
        "The step's output is 71 KB as JSON; a step's output can be at most 64 KB. Return only what later steps need."
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn unattended_typescript_gets_its_arguments_and_no_credential_or_raw_network() {
    let (_root, service) = setup(Limits::default()).await;
    let source = r#"
type Context = { macro: object; trigger: { subject: string } };
export async function main(context: Context): Promise<object> {
  let net = "loaded";
  try { await import("node:" + "net"); } catch { net = "unavailable"; }
  return {
    keys: Object.keys(context).sort(),
    subject: context.trigger.subject,
    connect: typeof Deno.connect,
    worker: typeof Worker,
    net,
  };
}
"#;
    let environment = unattended(
        "fixture-run-token",
        &[],
        serde_json::json!({"trigger": {"subject": "Invoice 7"}}),
        true,
    );
    let (_, outcome) = run_unattended(&service, source, environment).await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(
        value,
        serde_json::json!({
            "keys": ["macro", "trigger"],
            "subject": "Invoice 7",
            "connect": "undefined",
            "worker": "undefined",
            "net": "unavailable",
        })
    );
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_dry_run_reads_but_sends_no_writes() {
    let (_root, service) = setup(Limits::default()).await;
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let host = format!("http://{}", listener.local_addr().unwrap());
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let request = read_request(&mut stream).await;
        assert!(request.starts_with("POST /decisions "), "{request}");
        respond(&mut stream, r#"{"probabilities":{"yes":0.9}}"#).await;
        // Nothing else reaches the API: the write is skipped and the raw
        // request is stopped in the process.
        assert!(
            tokio::time::timeout(Duration::from_millis(500), listener.accept())
                .await
                .is_err()
        );
    });
    let source = r#"
export async function main({ macro, host }: { macro: any; host: string }) {
  const decision = await macro.ai.decide({ input: "x", questions: { yes: "Yes?" } });
  const archived = await macro._client.email.archiveThread({ path: { id: "thread-1" }, body: { archived: true } });
  const token = macro._client.email.client.getConfig().auth;
  let raw = "sent";
  try {
    await fetch(`${host}/email/labels`, { method: "POST", headers: { authorization: `Bearer ${token}` } });
  } catch (error) {
    raw = String(error);
  }
  return { yes: decision.probabilities.yes, archived: archived.data, raw };
}
"#;
    let environment = unattended(
        "fixture-run-token",
        &[("cognition", host.clone()), ("email", host.clone())],
        serde_json::json!({ "host": host }),
        true,
    );
    let (progress, outcome) = run_unattended(&service, source, environment).await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(value["yes"], 0.9);
    assert_eq!(value["archived"], serde_json::json!({}));
    assert!(
        value["raw"]
            .as_str()
            .unwrap()
            .contains("A dry run doesn't send changes."),
        "{value}"
    );
    assert!(progress.iter().any(|event| event["service"] == "email"
        && event["operation"] == "archiveThread"
        && event["status"] == "skipped"));
    server.await.unwrap();
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn a_real_run_sends_its_writes() {
    let (_root, service) = setup(Limits::default()).await;
    let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
    let host = format!("http://{}", listener.local_addr().unwrap());
    let server = tokio::spawn(async move {
        let (mut stream, _) = listener.accept().await.unwrap();
        let request = read_request(&mut stream).await;
        assert!(request.starts_with("DELETE "), "{request}");
        respond(&mut stream, "{}").await;
    });
    let source = r#"
export async function main({ macro }: { macro: any }) {
  await macro._client.storage.deleteDocument({ path: { document_id: "document-1" } });
  return { deleted: true };
}
"#;
    let environment = unattended(
        "fixture-run-token",
        &[("storage", host.clone())],
        serde_json::json!({}),
        false,
    );
    let (progress, outcome) = run_unattended(&service, source, environment).await;
    let Outcome::Succeeded { value } = outcome else {
        panic!("{outcome:?}");
    };
    assert_eq!(value["deleted"], true);
    assert!(
        progress
            .iter()
            .any(|event| event["operation"] == "deleteDocument" && event["status"] == "completed")
    );
    server.await.unwrap();
    service.shutdown().await;
}

#[tokio::test]
#[ignore = "requires pinned Deno runtime"]
async fn the_cpu_limit_stops_a_busy_program() {
    let (_root, service) = setup(Limits {
        max_cpu: Some(Duration::from_secs(1)),
        background: true,
        ..Limits::default()
    })
    .await;
    let (_, outcome) = run(
        &service,
        "export async function main() { for (;;) {} }",
        10_000,
    )
    .await;
    assert!(
        matches!(&outcome, Outcome::Failed { error } if error.code == FailureCode::Limit && error.message.contains("CPU")),
        "{outcome:?}"
    );
    service.shutdown().await;
}