Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

21.8 KB
Raw Blame
use super::*;
use crate::delegation::acp::{AcpSessionBinding, AcpSessionStart};
use crate::delegation::profile::{
    CandidateWorkerProfile, ProfileInput, SessionRootUse, TaskSessionRoot,
};
use hiroute_domain::ProtectedSecret;
use hiroute_domain::delegation::*;
use std::sync::Mutex;
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio_util::sync::CancellationToken;

#[cfg(unix)]
mod codex_capability;
mod startup;
mod terminal;

#[derive(Default)]
struct Journal(
    Mutex<Vec<&'static str>>,
    Option<Arc<crate::delegation::finalization::DelegationFinalization>>,
    std::sync::atomic::AtomicBool,
    Option<WorkerProgressWriter>,
);
impl AcpRunJournal for Journal {
    fn session_bound(&self, _: &AcpSessionBinding) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("session");
        Ok(())
    }
    fn before_prompt(&self) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("prompt");
        Ok(())
    }
    fn text_update(&self, _: &str) -> Result<(), DelegationErrorV1> {
        Ok(())
    }
    fn allow_permission_once(&self, _: &serde_json::Value) -> bool {
        false
    }
}
impl WorkerRunJournal for Journal {
    fn progress_writer(&self) -> Option<WorkerProgressWriter> {
        self.3.clone()
    }

    fn begin_finalization(
        &self,
    ) -> Option<crate::delegation::finalization::DelegationFinalizationLease> {
        self.1.as_ref().map(|finalization| finalization.acquire())
    }

    fn before_launch(&self) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("authorize");
        if self.2.load(std::sync::atomic::Ordering::SeqCst) {
            Err(DelegationErrorV1::PermissionDenied)
        } else {
            Ok(())
        }
    }
    fn process_spawned(&self, _: &WorkerProcessIdentity) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("spawned");
        Ok(())
    }
    fn stop_intent(&self) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("revoke");
        Ok(())
    }
    fn completed(&self, _: &AcpRunOutcome) -> Result<(), DelegationErrorV1> {
        if let Some(finalization) = self.1.as_ref() {
            assert!(
                finalization.try_acquire().is_none(),
                "terminal publication must happen under the finalization lease"
            );
        }
        self.0.lock().unwrap().push("completed");
        Ok(())
    }
    fn execution_failed(&self, _: DelegationErrorV1) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("failed");
        Ok(())
    }
    fn spawned_unrecorded(&self) -> Result<(), DelegationErrorV1> {
        self.0.lock().unwrap().push("spawn-unknown");
        Ok(())
    }
}

struct Fixture {
    journal: Arc<Journal>,
    methods: Arc<Mutex<Vec<String>>>,
    disconnect: bool,
    contradictory_stop: bool,
}
#[async_trait::async_trait]
impl WorkerPlatformPort for Fixture {
    fn capabilities(
        &self,
        _: &CandidateWorkerProfile,
    ) -> Result<WorkerPlatformCapabilities, DelegationErrorV1> {
        Ok(WorkerPlatformCapabilities {
            can_start: true,
            can_stop: true,
        })
    }
    async fn launch(&self, request: WorkerLaunchRequest) -> Result<ReadyWorker, DelegationErrorV1> {
        self.journal.0.lock().unwrap().push("spawn");
        let (client, server) = tokio::io::duplex(8192);
        let methods = self.methods.clone();
        let disconnect = self.disconnect;
        tokio::spawn(async move {
            let (r, mut w) = tokio::io::split(server);
            let mut lines = BufReader::new(r).lines();
            while let Ok(Some(line)) = lines.next_line().await {
                let req: serde_json::Value = serde_json::from_str(&line).unwrap();
                let method = req["method"].as_str().unwrap();
                methods.lock().unwrap().push(method.into());
                let result = match method {
                    "initialize" => {
                        serde_json::json!({"protocolVersion":1,"agentCapabilities":{"loadSession":true},"_meta":{"jetbrains":{"air":{"version":1,"capabilities":["sessionFailure"]}}}})
                    }
                    "session/new" => serde_json::json!({
                        "sessionId":"native-session",
                        "modes":{
                            "currentModeId":"default",
                            "availableModes":[
                                {"id":"default","name":"Manual"},
                                {"id":"agent-full-access","name":"Full access"}
                            ]
                        }
                    }),
                    "session/set_mode" => {
                        assert_eq!(req["params"]["sessionId"], "native-session");
                        assert_eq!(req["params"]["modeId"], "agent-full-access");
                        serde_json::json!({})
                    }
                    "session/prompt" if disconnect => break,
                    "session/prompt" => serde_json::json!({"stopReason":"end_turn"}),
                    "session/cancel" => continue,
                    _ => panic!("unexpected method {method}"),
                };
                let response = serde_json::json!({"jsonrpc":"2.0","id":req["id"],"result":result});
                if w.write_all(format!("{response}\n").as_bytes())
                    .await
                    .is_err()
                {
                    break;
                }
            }
        });
        let (stdout, stdin) = tokio::io::split(client);
        Ok(ReadyWorker {
            identity: WorkerProcessIdentity {
                launch_nonce: request.launch_nonce,
                handle_id: "held-child".into(),
                creation_identity: "creation".into(),
            },
            stdin: Box::pin(stdin),
            stdout: Box::pin(stdout),
        })
    }
    async fn observe(
        &self,
        _: &WorkerProcessIdentity,
    ) -> Result<WorkerObservation, DelegationErrorV1> {
        Ok(WorkerObservation::Running)
    }
    async fn terminate(
        &self,
        identity: &WorkerProcessIdentity,
        bound: u64,
    ) -> Result<WorkerStopEvidence, DelegationErrorV1> {
        assert_eq!(identity.handle_id, "held-child");
        assert_eq!(bound, STOP_WAIT_MS);
        assert_eq!(self.journal.0.lock().unwrap().last(), Some(&"revoke"));
        self.journal.0.lock().unwrap().push("stop");
        Ok(WorkerStopEvidence {
            scope: WorkerStopScope::Root,
            observation: if self.contradictory_stop {
                WorkerObservation::Running
            } else {
                WorkerObservation::Exited { code: Some(0) }
            },
            scope_stopped: true,
            residual_unknown: false,
        })
    }
}

fn inputs() -> (
    WorkerLaunchRequest,
    AcpRunInput,
    crate::test_support::PrivateTempDir,
) {
    inputs_in_context(None)
}

fn inputs_in_context(
    borrowed_root: Option<&std::path::Path>,
) -> (
    WorkerLaunchRequest,
    AcpRunInput,
    crate::test_support::PrivateTempDir,
) {
    inputs_for_harness(borrowed_root, WorkerHarnessV1::CodexCli)
}

fn inputs_for_harness(
    borrowed_root: Option<&std::path::Path>,
    worker_harness: WorkerHarnessV1,
) -> (
    WorkerLaunchRequest,
    AcpRunInput,
    crate::test_support::PrivateTempDir,
) {
    let fixture = crate::test_support::private_tempdir();
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(fixture.path(), std::fs::Permissions::from_mode(0o700)).unwrap();
    }
    let session = TaskSessionRoot::prepare(
        fixture.path(),
        &hiroute_domain::WorkspaceId::parse("workspace").unwrap(),
        "root",
        "task-a",
        worker_harness,
        SessionRootUse::New,
    )
    .unwrap();
    let cwd = std::env::temp_dir();
    let adapter = cwd.join("adapter");
    let harness = cwd.join("codex");
    let private =
        crate::delegation::profile::native_context_path(&fixture.path().canonicalize().unwrap())
            .join("run");
    let permit = WorkspaceExecutionPermitV1 {
        permit_id: "permit".into(),
        generation: 1,
        root_identity: "root".into(),
        access: WorkspaceAccessV1::TrustedNative,
        tools: vec![WorkerToolV1::Read, WorkerToolV1::Shell],
        network: WorkerNetworkV1::Allowed,
        expires_at_ms: 10000,
        max_run_ms: 1000,
        max_concurrent: 2,
        revoked: false,
    };
    let execution = WorkerExecutionIntentV1 {
        root_identity: "root".into(),
        access: WorkspaceAccessV1::TrustedNative,
        tools: permit.tools.clone(),
        network: WorkerNetworkV1::Allowed,
        duration_ms: 1000,
        delegation_depth: 1,
    };
    let native_context = match borrowed_root {
        Some(root) => {
            crate::delegation::profile::NativeWorkerContext::borrowed(fixture.path(), root)
        }
        None => crate::delegation::profile::NativeWorkerContext::isolated(&private, session.path()),
    }
    .unwrap();
    let catalog =
        borrowed_root.map(|_| crate::delegation::profile::test_codex_catalog("fixed-alias"));
    let profile = CandidateWorkerProfile::build(ProfileInput {
        protocol: hiroute_domain::AgentIngressProtocolV1::Responses,
        context_window_tokens: None,
        max_output_tokens: None,
        harness: worker_harness,
        adapter: Some(&adapter),
        harness_binary: &harness,
        node_binary: None,
        private_root: &private,
        session_root: &session,
        native_context: &native_context,
        workspace: &cwd,
        alias: "fixed-alias",
        codex_catalog: catalog.as_deref(),
        native_effort: None,
        gateway: "127.0.0.1:10001".parse().unwrap(),
        permit: &permit,
        execution: &execution,
        permission_policy: WorkerPermissionPolicyV1::ApproveAll,
        admitted_at_ms: 1,
        token: ProtectedSecret::new(b"fixture-token".to_vec()).unwrap(),
    })
    .unwrap();
    let input = AcpRunInput {
        cwd,
        prompt: "fixture only".into(),
        session: AcpSessionStart::New,
        identity_contract: profile.identity_contract.clone(),
        session_meta: profile.session_meta.clone(),
        native_session_mode: Some(profile.native_session_mode().to_owned()),
        expected_model: None,
        authentication: None,
        deadline: Instant::now() + Duration::from_secs(1),
        cancellation: CancellationToken::new(),
    };
    (
        WorkerLaunchRequest {
            launch_nonce: "launch".into(),
            profile,
            deadline_unix_ms: 1001,
        },
        input,
        fixture,
    )
}

#[tokio::test]
#[cfg(unix)]
async fn managed_process_reports_real_acp_new_load_failure_and_timeout_without_preprobe() {
    use crate::delegation::local_worker::LocalWorkerPlatform;
    use std::time::{SystemTime, UNIX_EPOCH};
    for case in ["new", "load", "incompatible", "timeout"] {
        let (mut request, mut input, fixture) = inputs();
        let script = fixture.path().join("adapter.py");
        let transcript = fixture.path().join("requests");
        std::fs::write(&script, r#"import json, os, sys, time
assert os.environ['HIROUTE_RUN_TOKEN'] == 'fixture-token'
assert os.environ['HOME'].endswith('/run/home')
case = sys.argv[1]
for line in sys.stdin:
    request = json.loads(line)
    method = request['method']
    with open(sys.argv[2], 'a') as log:
        log.write(method + '\n')
    if case == 'timeout':
        time.sleep(10)
    if case == 'incompatible':
        print('not-json', flush=True)
        break
    modes = {'currentModeId':'agent-full-access','availableModes':[{'id':'agent-full-access','name':'Autonomous'}]}
    if method == 'initialize':
        result = {'protocolVersion':1,'agentCapabilities':{'loadSession':True},'_meta':{'jetbrains':{'air':{'version':1,'capabilities':['sessionFailure']}}}}
    elif method == 'session/new':
        assert case == 'new'
        result = {'sessionId':'native-session','modes':modes}
    elif method == 'session/load':
        assert case == 'load'
        assert request['params']['sessionId'] == 'native-session'
        result = {'modes':modes}
    elif method == 'session/set_mode':
        result = {}
    elif method == 'session/prompt':
        result = {'stopReason':'end_turn'}
    else:
        raise AssertionError(method)
    print(json.dumps({'jsonrpc':'2.0','id':request['id'],'result':result}), flush=True)
"#).unwrap();
        request.profile.executable = std::path::PathBuf::from("/usr/bin/python3");
        request.profile.args = vec![script, case.into(), transcript.clone()];
        request.deadline_unix_ms = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64
            + 5_000;
        input.deadline = Instant::now()
            + if case == "timeout" {
                Duration::from_millis(500)
            } else {
                Duration::from_secs(5)
            };
        if case == "load" {
            input.session = AcpSessionStart::Load(AcpSessionBinding {
                acp_session_id: "native-session".into(),
                native_session_id: Some("native-session".into()),
            });
        }
        let private_root = request.profile.private_root.clone();
        let platform = LocalWorkerPlatform::default();
        let started = Instant::now();
        let result = execute(&platform, request, input, Arc::new(Journal::default()))
            .await
            .unwrap();
        match case {
            "new" | "load" => assert_eq!(
                result
                    .execution
                    .unwrap()
                    .session
                    .native_session_id
                    .as_deref(),
                Some("native-session")
            ),
            "timeout" => {
                assert!(matches!(
                    result.execution,
                    Err(DelegationErrorV1::DeadlineExceeded | DelegationErrorV1::Cancelled)
                ));
                assert!(started.elapsed() < Duration::from_secs(7));
            }
            _ => assert!(result.execution.is_err()),
        }
        assert!(result.stop.unwrap().scope_stopped);
        assert!(!private_root.exists());
        let methods = std::fs::read_to_string(transcript).unwrap();
        assert_eq!(
            methods
                .lines()
                .filter(|method| *method == "initialize")
                .count(),
            1
        );
        if case == "load" {
            assert!(!methods.contains("session/new"));
        }
        if case == "incompatible" || case == "timeout" {
            assert!(!methods.contains("session/prompt"));
        }
    }
}

#[tokio::test]
async fn spawn_stdio_acp_result_and_owned_cleanup_need_no_helper_handshake() {
    let journal = Arc::new(Journal::default());
    let backend = Fixture {
        journal: journal.clone(),
        methods: Arc::default(),
        disconnect: false,
        contradictory_stop: false,
    };
    let (request, input, _fixture) = inputs();
    let result = execute(&backend, request, input, journal.clone())
        .await
        .unwrap();
    assert!(result.native_history_settled);
    assert_eq!(
        result
            .execution
            .unwrap()
            .session
            .native_session_id
            .as_deref(),
        Some("native-session")
    );
    assert!(result.stop.unwrap().scope_stopped);
    assert_eq!(
        *journal.0.lock().unwrap(),
        [
            "authorize",
            "spawn",
            "spawned",
            "session",
            "prompt",
            "completed",
            "revoke",
            "stop"
        ]
    );
}

#[tokio::test]
async fn terminal_publication_lease_survives_until_the_executor_receives_the_result() {
    let finalization = Arc::new(crate::delegation::finalization::DelegationFinalization::default());
    let journal = Arc::new(Journal(
        Mutex::default(),
        Some(Arc::clone(&finalization)),
        Default::default(),
        None,
    ));
    let backend = Fixture {
        journal: Arc::clone(&journal),
        methods: Arc::default(),
        disconnect: false,
        contradictory_stop: false,
    };
    let (request, input, _fixture) = inputs();

    let result = execute(&backend, request, input, journal).await.unwrap();

    assert!(finalization.try_acquire().is_none());
    drop(result);
    assert!(finalization.try_acquire().is_some());
}

#[tokio::test]
async fn claude_history_checkpoint_observes_new_and_appended_stable_transcripts() {
    for existing in [false, true] {
        let root = crate::test_support::private_tempdir();
        let session_id = format!("native-{existing}");
        let history = root
            .path()
            .join("projects/workspace")
            .join(format!("{session_id}.jsonl"));
        fixture_private_directory(&root.path().join("projects"));
        fixture_private_directory(history.parent().unwrap());
        let baseline = if existing {
            hiroute_platform::durable::write_private_new(&history, b"old\n").unwrap();
            HistoryBaseline::Existing(4)
        } else {
            hiroute_platform::durable::write_private_new(&history, b"").unwrap();
            HistoryBaseline::New
        };
        let checkpoint = ClaudeHistoryCheckpoint {
            root: root.path().to_owned(),
            baseline,
        };
        let history_for_write = history.clone();
        let writer = tokio::spawn(async move {
            tokio::time::sleep(Duration::from_millis(40)).await;
            use std::io::Write;
            let mut file = std::fs::OpenOptions::new()
                .append(true)
                .open(history_for_write)
                .unwrap();
            file.write_all(b"new\n").unwrap();
            file.sync_all().unwrap();
        });
        assert!(
            checkpoint
                .wait_until_settled(Some(session_id.as_str()))
                .await
        );
        writer.await.unwrap();
    }
}

#[tokio::test]
async fn borrowed_claude_checkpoint_observes_native_file_instead_of_owned_binding() {
    let storage = crate::test_support::private_tempdir();
    let workspace = storage.path().join("workspace");
    let home = storage.path().join("daily-home");
    let config = home.join("native-config");
    fixture_private_directory(&home);
    fixture_private_directory(&config);
    fixture_private_directory(&workspace);
    let session = TaskSessionRoot::prepare(
        storage.path(),
        &hiroute_domain::WorkspaceId::parse("workspace").unwrap(),
        "root",
        "task",
        WorkerHarnessV1::ClaudeCode,
        SessionRootUse::New,
    )
    .unwrap();
    session
        .bind_borrowed_context(&home, &config, &workspace)
        .unwrap();
    let project =
        crate::delegation::profile::native_context_path(&fs::canonicalize(workspace).unwrap())
            .to_str()
            .unwrap()
            .replace(|ch: char| !ch.is_ascii_alphanumeric(), "-");
    let id = "71a2b020-312e-49cd-b084-924cbb3642ad";
    let history = config
        .join("projects")
        .join(project)
        .join(format!("{id}.jsonl"));
    fixture_private_directory(&config.join("projects"));
    fixture_private_directory(history.parent().unwrap());
    hiroute_platform::durable::write_private_new(&history, b"old\n").unwrap();
    crate::delegation::profile::native_history(session.path(), WorkerHarnessV1::ClaudeCode, id)
        .unwrap();
    assert_eq!(claude_history_len(session.path(), id), Some(4));
    let checkpoint = ClaudeHistoryCheckpoint {
        root: session.path().to_owned(),
        baseline: HistoryBaseline::Existing(4),
    };
    let writer = tokio::spawn(async move {
        tokio::time::sleep(Duration::from_millis(40)).await;
        use std::io::Write;
        let mut file = fs::OpenOptions::new().append(true).open(history).unwrap();
        file.write_all(b"new\n").unwrap();
        file.sync_all().unwrap();
    });
    assert!(checkpoint.wait_until_settled(Some(id)).await);
    writer.await.unwrap();
    assert_eq!(claude_history_len(session.path(), id), Some(8));
}

fn fixture_private_directory(path: &std::path::Path) {
    #[cfg(windows)]
    drop(hiroute_platform::windows::security::create_owner_only_directory(path).unwrap());
    #[cfg(not(windows))]
    {
        let mut builder = fs::DirBuilder::new();
        #[cfg(unix)]
        {
            use std::os::unix::fs::DirBuilderExt;
            builder.mode(0o700);
        }
        builder.create(path).unwrap();
    }
}

#[tokio::test]
async fn prompt_disconnect_never_respawns_or_replays_and_cleanup_is_not_completion() {
    let journal = Arc::new(Journal::default());
    let backend = Fixture {
        journal: journal.clone(),
        methods: Arc::default(),
        disconnect: true,
        contradictory_stop: false,
    };
    let (request, input, _fixture) = inputs();
    let result = execute(&backend, request, input, journal).await.unwrap();
    assert!(result.execution.is_err());
    assert!(result.stop.unwrap().scope_stopped);
    assert_eq!(
        backend
            .methods
            .lock()
            .unwrap()
            .iter()
            .filter(|m| m.as_str() == "session/prompt")
            .count(),
        1
    );
}

#[tokio::test]
async fn contradictory_stop_is_unknown_and_pre_cancel_does_not_spawn() {
    let journal = Arc::new(Journal::default());
    let backend = Fixture {
        journal: journal.clone(),
        methods: Arc::default(),
        disconnect: false,
        contradictory_stop: true,
    };
    let (request, input, _fixture) = inputs();
    let result = execute(&backend, request, input, journal.clone())
        .await
        .unwrap();
    assert!(result.stop.is_none());
    journal.0.lock().unwrap().clear();
    let (request, input, _fixture) = inputs();
    input.cancellation.cancel();
    assert_eq!(
        execute(&backend, request, input, journal.clone())
            .await
            .err(),
        Some(DelegationErrorV1::Cancelled)
    );
    assert_eq!(*journal.0.lock().unwrap(), ["failed"]);
}