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.

18.5 KB
Raw Blame
//! Selected Harness configuration and native permission policy owned by MVP-20.
//! The platform checks basic installation/start/stop, not universal confinement.
use super::acp::AcpNativeIdentityContract;
use hiroute_domain::ProtectedSecret;
use hiroute_domain::delegation::{
    DelegationErrorV1, WorkerExecutionIntentV1, WorkerHarnessV1, WorkerLaunchFormV1,
    WorkerNetworkV1, WorkerPermissionPolicyV1, WorkerToolV1, WorkspaceAccessV1,
    WorkspaceExecutionPermitV1,
};
use serde_json::{Map, Value, json};
use std::collections::BTreeMap;
use std::net::SocketAddr;
use std::path::{Path, PathBuf};
use zeroize::Zeroizing;

mod capabilities;
mod claude;
mod claude_runtime;
mod codex;
mod dsh;
mod native_context;
mod opencode;
mod pi;
mod qoder;
pub use native_context::NativeWorkerContext;
#[cfg(test)]
pub(crate) use native_context::native_path as native_context_path;
#[cfg(windows)]
pub(crate) use native_context::{same_windows_directory, windows_workspace};

mod materials;
pub(crate) use materials::native_history;
pub use materials::{
    BorrowedNativeContext, RunMaterialFile, RunMaterials, SessionRootUse, TaskSessionRoot,
};

pub struct ProfileInput<'a> {
    pub protocol: hiroute_domain::AgentIngressProtocolV1,
    pub context_window_tokens: Option<u64>,
    /// Qoder's frozen catalogue output upper bound; other Harness renderers are unchanged.
    pub max_output_tokens: Option<u64>,
    pub harness: WorkerHarnessV1,
    pub adapter: Option<&'a Path>,
    pub harness_binary: &'a Path,
    pub node_binary: Option<&'a Path>,
    pub private_root: &'a Path,
    pub session_root: &'a TaskSessionRoot,
    pub native_context: &'a NativeWorkerContext,
    pub workspace: &'a Path,
    pub alias: &'a str,
    /// One alias entry derived from the exact frozen Plan, stored in the owned task root.
    pub codex_catalog: Option<&'a [u8]>,
    pub native_effort: Option<&'a str>,
    pub gateway: SocketAddr,
    pub permit: &'a WorkspaceExecutionPermitV1,
    pub execution: &'a WorkerExecutionIntentV1,
    pub permission_policy: WorkerPermissionPolicyV1,
    pub admitted_at_ms: u64,
    pub token: ProtectedSecret,
}

/// No Debug/Serialize/Clone: the environment contains one run's downstream secret.
pub struct CandidateWorkerProfile {
    pub executable: PathBuf,
    pub args: Vec<PathBuf>,
    pub cwd: PathBuf,
    pub private_root: PathBuf,
    pub session_root: PathBuf,
    pub materials: RunMaterials,
    pub env: BTreeMap<String, Zeroizing<String>>,
    pub session_meta: Map<String, Value>,
    pub identity_contract: AcpNativeIdentityContract,
    access: WorkspaceAccessV1,
    network: WorkerNetworkV1,
    tools: Vec<WorkerToolV1>,
    permission_policy: WorkerPermissionPolicyV1,
    native_session_mode: String,
    native_selected_model_id: String,
    native_initialization_root: Option<PathBuf>,
    opencode_startup: Option<opencode::StartupAdmission>,
}

pub use super::platform::WorkerPlatformCapabilities;

impl CandidateWorkerProfile {
    pub fn build(input: ProfileInput<'_>) -> Result<Self, DelegationErrorV1> {
        input.permit.authorize(
            input.execution,
            input.admitted_at_ms,
            input.permit.generation,
        )?;
        let identity_contract = capabilities::identity_contract(&input)?;
        let selection = hiroute_domain::WorkerDependencySelectionRecordV1 {
            harness: input.harness,
            adapter_path: input.adapter.map(path_string).transpose()?,
            cli_path: path_string(input.harness_binary)?,
            node_path: input.node_binary.map(path_string).transpose()?,
        };
        let launch = selection
            .validated_launch()
            .map_err(|_| DelegationErrorV1::InvalidArguments)?;
        if ![input.harness_binary, input.private_root, input.workspace]
            .iter()
            .all(|p| p.is_absolute())
            || input.node_binary.is_some_and(|p| !p.is_absolute())
            || !input.gateway.is_ipv4()
            || input.gateway.ip().is_unspecified()
            || input.gateway.port() == 0
            || input.alias.is_empty()
            || input.alias.len() > 128
            || !input
                .alias
                .bytes()
                .all(|b| b.is_ascii_alphanumeric() || b"/._-:".contains(&b))
            || input.permit.revoked
        {
            return Err(DelegationErrorV1::InvalidArguments);
        }
        secret_str(&input.token)?;
        input
            .session_root
            .check_binding(input.harness, &input.execution.root_identity)?;
        let (access, network, projected_tools) = match input.permission_policy {
            WorkerPermissionPolicyV1::ApproveAll => (
                WorkspaceAccessV1::TrustedNative,
                WorkerNetworkV1::Allowed,
                vec![WorkerToolV1::Read, WorkerToolV1::Edit, WorkerToolV1::Shell],
            ),
            WorkerPermissionPolicyV1::ApproveReads => (
                WorkspaceAccessV1::ReadOnly,
                WorkerNetworkV1::GatewayOnly,
                vec![WorkerToolV1::Read],
            ),
            WorkerPermissionPolicyV1::DenyAll => (
                WorkspaceAccessV1::ReadOnly,
                WorkerNetworkV1::GatewayOnly,
                Vec::new(),
            ),
        };
        let private_root = materials::checked_run_root(input.private_root, input.session_root)?;
        if input.native_context.is_borrowed() {
            if input.native_context.home().starts_with(&private_root)
                || input
                    .native_context
                    .config_root()
                    .starts_with(&private_root)
                || input
                    .native_context
                    .config_root()
                    .starts_with(input.session_root.path())
            {
                return Err(DelegationErrorV1::InvalidArguments);
            }
        } else if input.native_context.home() != private_root.join("home")
            || input.native_context.config_root() != input.session_root.path()
        {
            return Err(DelegationErrorV1::InvalidArguments);
        }
        let native_session_mode = match (input.harness, input.permission_policy) {
            (WorkerHarnessV1::CodexCli, WorkerPermissionPolicyV1::ApproveAll) => {
                "agent-full-access"
            }
            (WorkerHarnessV1::CodexCli, _) => "read-only",
            (WorkerHarnessV1::ClaudeCode, WorkerPermissionPolicyV1::ApproveAll) => {
                "bypassPermissions"
            }
            (WorkerHarnessV1::ClaudeCode, _) => "default",
            (WorkerHarnessV1::QoderCli, WorkerPermissionPolicyV1::ApproveAll) => "yolo",
            (WorkerHarnessV1::Pi, WorkerPermissionPolicyV1::ApproveAll) => "approve-all",
            (WorkerHarnessV1::Pi, _) => return Err(DelegationErrorV1::CapabilityUnavailable),
            (WorkerHarnessV1::OpenCode, WorkerPermissionPolicyV1::ApproveAll) => opencode::MODE,
            (WorkerHarnessV1::OpenCode, _) => return Err(DelegationErrorV1::CapabilityUnavailable),
            (WorkerHarnessV1::DeepseekHarness, WorkerPermissionPolicyV1::ApproveAll) => "",
            (WorkerHarnessV1::DeepseekHarness, _) => {
                return Err(DelegationErrorV1::CapabilityUnavailable);
            }
            (WorkerHarnessV1::QoderCli, _) => return Err(DelegationErrorV1::CapabilityUnavailable),
        };
        let mut env = BTreeMap::new();
        // This is a new child environment, never merged with std::env::vars().
        // Tool discovery is not authentication. Keep an explicit command search
        // path while leaving ambient model credentials behind. Native context selectors are explicit.
        env.insert(
            "PATH".into(),
            Zeroizing::new(worker_path(
                input.harness_binary,
                input.node_binary,
                input.adapter,
            )?),
        );
        env.insert(
            "HOME".into(),
            Zeroizing::new(path_string(input.native_context.home())?),
        );
        env.insert(
            "TMPDIR".into(),
            Zeroizing::new(path_string(&private_root.join("tmp"))?),
        );
        #[cfg(windows)]
        {
            // Windows tools require these OS selectors, without borrowing model credentials.
            for (name, value) in hiroute_integrations::agents::windows_native_system_environment()
                .map_err(|_| DelegationErrorV1::CapabilityUnavailable)?
            {
                let value = value
                    .into_string()
                    .map_err(|_| DelegationErrorV1::CapabilityUnavailable)?;
                env.insert(name.into(), Zeroizing::new(value));
            }
            env.insert(
                "USERPROFILE".into(),
                Zeroizing::new(path_string(input.native_context.home())?),
            );
            for (name, relative) in [
                ("APPDATA", "AppData/Roaming"),
                ("LOCALAPPDATA", "AppData/Local"),
            ] {
                env.insert(
                    name.into(),
                    Zeroizing::new(path_string(&input.native_context.home().join(relative))?),
                );
            }
            env.insert(
                "ProgramFiles".into(),
                Zeroizing::new(path_string(
                    &hiroute_platform::windows::background::program_files()
                        .map_err(|_| DelegationErrorV1::CapabilityUnavailable)?,
                )?),
            );
            for name in ["TEMP", "TMP"] {
                env.insert(
                    name.into(),
                    Zeroizing::new(path_string(&private_root.join("tmp"))?),
                );
            }
        }
        if input.harness == WorkerHarnessV1::ClaudeCode && input.native_context.is_borrowed() {
            // Only the explicitly selected Node can establish the adapter environment guard.
            // An executable adapter discovered without a runtime remains discoverable, but
            // cannot silently start with unguarded borrowed settings.
            input
                .node_binary
                .ok_or(DelegationErrorV1::CapabilityUnavailable)?;
            claude_runtime::require_host_managed_provider(
                input.harness_binary,
                env["PATH"].as_str(),
            )?;
        }
        let rendered = match input.harness {
            WorkerHarnessV1::CodexCli => {
                codex::render(&input, &projected_tools, network, native_session_mode)?
            }
            WorkerHarnessV1::ClaudeCode => claude::render(&input, &projected_tools)?,
            WorkerHarnessV1::QoderCli => qoder::render(&input, &private_root)?,
            WorkerHarnessV1::Pi => pi::render(&input)?,
            WorkerHarnessV1::DeepseekHarness => dsh::render(&input)?,
            WorkerHarnessV1::OpenCode => opencode::render(&input, env["PATH"].as_str())?,
        };
        env.extend(rendered.env);
        let (executable, args) = match launch {
            WorkerLaunchFormV1::NativeSdk { cli, node } => (
                PathBuf::from(node),
                vec![
                    private_root.join("pi-worker-bridge.mjs"),
                    PathBuf::from(cli),
                ],
            ),
            WorkerLaunchFormV1::NativeAcp { cli } => (PathBuf::from(cli), rendered.native_args),
            WorkerLaunchFormV1::AdapterAcp { adapter, node, .. } => {
                if let Some(bootstrap) = rendered.adapter_bootstrap {
                    (
                        PathBuf::from(node.ok_or(DelegationErrorV1::CapabilityUnavailable)?),
                        vec![private_root.join(bootstrap), PathBuf::from(adapter)],
                    )
                } else {
                    node.map_or_else(
                        || (PathBuf::from(adapter), vec![]),
                        |node| (PathBuf::from(node), vec![PathBuf::from(adapter)]),
                    )
                }
            }
        };
        #[cfg(windows)]
        let (executable, args) = hiroute_integrations::agents::windows_agent_command(
            &executable,
            &args,
            env["PATH"].as_str(),
        )
        .map_err(|_| DelegationErrorV1::CapabilityUnavailable)?;
        Ok(Self {
            executable,
            args,
            cwd: input.workspace.to_owned(),
            private_root,
            session_root: input.session_root.path().to_owned(),
            materials: RunMaterials {
                directories: if input.native_context.is_borrowed() {
                    vec!["tmp".into()]
                } else {
                    vec!["home".into(), "tmp".into()]
                },
                files: rendered.files,
            },
            env,
            session_meta: rendered.session_meta,
            identity_contract,
            access,
            network,
            tools: projected_tools,
            permission_policy: input.permission_policy,
            native_session_mode: native_session_mode.to_owned(),
            native_selected_model_id: rendered.native_model_id,
            native_initialization_root: rendered
                .opencode_startup
                .as_ref()
                .map(|admission| admission.root().to_owned())
                .or_else(|| {
                    (input.harness == WorkerHarnessV1::CodexCli
                        && input.native_context.is_borrowed())
                    .then(|| input.native_context.config_root().to_owned())
                }),
            opencode_startup: rendered.opencode_startup,
        })
    }

    pub fn access(&self) -> WorkspaceAccessV1 {
        self.access
    }
    pub fn network(&self) -> WorkerNetworkV1 {
        self.network
    }
    pub fn tools(&self) -> &[WorkerToolV1] {
        &self.tools
    }

    /// Exact adapter-owned session mode that must be advertised and selected before prompting.
    pub fn native_session_mode(&self) -> &str {
        &self.native_session_mode
    }

    /// The exact native selector ID. Plan/Gateway authorization still uses the raw alias.
    pub fn native_selected_model_id(&self) -> &str {
        &self.native_selected_model_id
    }

    /// The installation owner has already bound the canonical effective native root.
    /// Never derive this coordination key from cwd, a model alias, or mutable child env.
    pub(crate) fn native_initialization_root(&self) -> Option<&Path> {
        self.native_initialization_root.as_deref()
    }

    pub(crate) fn validate_native_initialization(
        &self,
        new_session: bool,
    ) -> Result<(), DelegationErrorV1> {
        if let Some(admission) = &self.opencode_startup {
            admission.validate(&self.cwd, new_session)?;
        }
        Ok(())
    }

    /// Compatibility check for callers that require a native Harness profile. Restricted
    /// policies are Harness configuration, not a different process-confinement capability.
    pub fn require_native_mode(&self) -> Result<(), DelegationErrorV1> {
        Ok(())
    }

    pub fn permission_limitations(&self) -> &'static str {
        "Caller-selected Harness approval/tool settings; no same-user filesystem or network sandbox"
    }

    /// Compatibility fallback for an unexpected request from the selected Harness. Approve-all
    /// normally uses the Harness's native autonomous mode and should not reach this callback.
    /// The journal additionally checks the current run lifecycle; no path grants persistence.
    pub fn allows_permission_once(&self, request: &Value) -> bool {
        match self.permission_policy {
            WorkerPermissionPolicyV1::ApproveAll => true,
            WorkerPermissionPolicyV1::ApproveReads => {
                request.pointer("/toolCall/kind").and_then(Value::as_str) == Some("read")
            }
            WorkerPermissionPolicyV1::DenyAll => false,
        }
    }

    pub fn require_platform(
        &self,
        facts: &WorkerPlatformCapabilities,
    ) -> Result<(), DelegationErrorV1> {
        if !facts.can_start || !facts.can_stop {
            return Err(DelegationErrorV1::CapabilityUnavailable);
        }
        self.require_native_mode()?;
        Ok(())
    }
}

#[cfg(test)]
pub(crate) fn test_codex_catalog(alias: &str) -> Vec<u8> {
    serde_json::to_vec(&json!({"models": [{
        "slug": alias, "display_name": "Private Worker", "priority": 0,
        "visibility": "list", "supported_in_api": true,
        "shell_type": "shell_command", "support_verbosity": false,
        "supported_reasoning_levels": [], "supports_parallel_tool_calls": false,
        "model_messages": {"instructions_template": "Private test Worker"},
        "truncation_policy": {"mode": "bytes", "limit": 10000},
        "experimental_supported_tools": []
    }]}))
    .unwrap()
}

#[derive(Default)]
struct RenderedHarnessProfile {
    env: BTreeMap<String, Zeroizing<String>>,
    session_meta: Map<String, Value>,
    files: Vec<RunMaterialFile>,
    adapter_bootstrap: Option<PathBuf>,
    native_args: Vec<PathBuf>,
    native_model_id: String,
    opencode_startup: Option<opencode::StartupAdmission>,
}

fn secret_str(secret: &ProtectedSecret) -> Result<&str, DelegationErrorV1> {
    let value =
        std::str::from_utf8(secret.expose()).map_err(|_| DelegationErrorV1::InvalidArguments)?;
    if value.len() > 4096 || !value.bytes().all(|b| b.is_ascii_graphic()) {
        return Err(DelegationErrorV1::InvalidArguments);
    }
    Ok(value)
}

fn secret_string(secret: &ProtectedSecret) -> Result<String, DelegationErrorV1> {
    secret_str(secret).map(str::to_owned)
}

fn path_string(path: &Path) -> Result<String, DelegationErrorV1> {
    native_context::native_path(path)
        .to_str()
        .filter(|s| !s.contains(['\n', '\r', '\0']))
        .map(str::to_owned)
        .ok_or(DelegationErrorV1::InvalidArguments)
}

fn worker_path(
    harness: &Path,
    node: Option<&Path>,
    adapter: Option<&Path>,
) -> Result<String, DelegationErrorV1> {
    let mut paths = Vec::new();
    for executable in [node, Some(harness), adapter].into_iter().flatten() {
        if let Some(parent) = executable.parent() {
            paths.push(parent.to_owned());
        }
    }
    if let Some(path) = std::env::var_os("PATH") {
        paths.extend(std::env::split_paths(&path).filter(|path| path.is_absolute()));
    }
    #[cfg(unix)]
    paths.extend(
        [
            "/opt/homebrew/bin",
            "/usr/local/bin",
            "/usr/bin",
            "/bin",
            "/usr/sbin",
            "/sbin",
        ]
        .map(PathBuf::from),
    );
    let mut unique = Vec::new();
    for path in paths {
        if !unique.contains(&path) {
            unique.push(path);
        }
    }
    std::env::join_paths(unique)
        .map_err(|_| DelegationErrorV1::InvalidArguments)?
        .into_string()
        .map_err(|_| DelegationErrorV1::InvalidArguments)
}

#[cfg(test)]
mod tests;