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.

19.7 KB
Raw Blame
use std::collections::BTreeSet;
#[cfg(any(not(windows), test))]
use std::ffi::OsStr;
use std::ffi::OsString;
use std::fs::File;
#[cfg(not(windows))]
use std::fs::OpenOptions;
use std::path::{Path, PathBuf};
use std::process::Command;

use hiroute_domain::{
    ConfigLayerV1, MANAGED_CLAUDE_ENVIRONMENT_REMOVALS_V1, MANAGED_CLAUDE_SETTINGS_ARGUMENT_V1,
    ManagedClaudeLaunchDescriptorV2, ManagedLaunchProfileV1,
};
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};

#[cfg(windows)]
#[path = "managed_launch/windows.rs"]
mod windows;
#[cfg(windows)]
pub(super) use windows::executable_path as windows_executable_path;

pub const MANAGED_LAUNCH_ENV_SANITIZED_V1: &str = "MANAGED_LAUNCH_ENV_SANITIZED";
pub const AGENT_AUTH_PRECEDENCE_CONFLICT_V1: &str = "AGENT_AUTH_PRECEDENCE_CONFLICT";

#[derive(Clone, Copy, Debug, Deserialize, Eq, Ord, PartialEq, PartialOrd, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum AgentAuthRoutingFieldV1 {
    AnthropicApiKey,
    AnthropicAuthToken,
    AnthropicBaseUrl,
    AnthropicCustomHeaders,
    AnthropicModel,
    ApiKeyHelper,
    Bedrock,
    Foundry,
    Vertex,
}

impl AgentAuthRoutingFieldV1 {
    pub(crate) fn from_environment_name(name: &str) -> Option<Self> {
        match name {
            "ANTHROPIC_API_KEY" => Some(Self::AnthropicApiKey),
            "ANTHROPIC_AUTH_TOKEN" => Some(Self::AnthropicAuthToken),
            "ANTHROPIC_BASE_URL" => Some(Self::AnthropicBaseUrl),
            "ANTHROPIC_CUSTOM_HEADERS" => Some(Self::AnthropicCustomHeaders),
            "ANTHROPIC_MODEL" => Some(Self::AnthropicModel),
            "CLAUDE_CODE_USE_BEDROCK" => Some(Self::Bedrock),
            "CLAUDE_CODE_USE_FOUNDRY" => Some(Self::Foundry),
            "CLAUDE_CODE_USE_VERTEX" => Some(Self::Vertex),
            _ => None,
        }
    }
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ManagedLaunchWarningV1 {
    pub code: String,
    pub environment_removals: BTreeSet<String>,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct AgentAuthPrecedenceConflictV1 {
    pub code: String,
    pub layer: ConfigLayerV1,
    pub source_ref: String,
    pub fields: BTreeSet<AgentAuthRoutingFieldV1>,
}

#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ManagedClaudeLaunchPreflightV1 {
    pub executable: String,
    pub inherited_environment_removals: BTreeSet<String>,
    pub warnings: Vec<ManagedLaunchWarningV1>,
    pub conflicts: Vec<AgentAuthPrecedenceConflictV1>,
}

impl ManagedClaudeLaunchPreflightV1 {
    pub(super) fn from_observations(
        executable: String,
        profile: &ManagedLaunchProfileV1,
        observations: &[super::filesystem_config::ObservedClaudeSettings],
    ) -> Self {
        let inherited_environment_removals = observations
            .iter()
            .filter(|observation| observation.layer == ConfigLayerV1::Process)
            .flat_map(|observation| observation.settings.env.present_environment_fields.iter())
            .filter(|name| profile.environment_removals.contains(*name))
            .cloned()
            .collect::<BTreeSet<_>>();
        let warnings = (!inherited_environment_removals.is_empty())
            .then(|| ManagedLaunchWarningV1 {
                code: MANAGED_LAUNCH_ENV_SANITIZED_V1.to_owned(),
                environment_removals: inherited_environment_removals.clone(),
            })
            .into_iter()
            .collect();
        let conflicts = observations
            .iter()
            // The managed launcher removes the complete process auth set and merges any explicit
            // caller --settings document into its private overlay. Normal setting-source, project,
            // MCP, permission and Skill semantics stay intact; only the routing/auth fields are
            // replaced. Launch facts (if an embedding supplies one) and machine-managed policy
            // cannot be excluded by that boundary and stay fatal.
            .filter(|observation| {
                matches!(
                    observation.layer,
                    ConfigLayerV1::Launch | ConfigLayerV1::Managed
                )
            })
            .filter_map(|observation| {
                let mut fields = observation
                    .settings
                    .env
                    .present_environment_fields
                    .iter()
                    .filter_map(|name| AgentAuthRoutingFieldV1::from_environment_name(name))
                    .collect::<BTreeSet<_>>();
                if observation.settings.api_key_helper_present {
                    fields.insert(AgentAuthRoutingFieldV1::ApiKeyHelper);
                }
                (!fields.is_empty()).then(|| AgentAuthPrecedenceConflictV1 {
                    code: AGENT_AUTH_PRECEDENCE_CONFLICT_V1.to_owned(),
                    layer: observation.layer,
                    source_ref: observation.source_ref.clone(),
                    fields,
                })
            })
            .collect();
        Self {
            executable,
            inherited_environment_removals,
            warnings,
            conflicts,
        }
    }

    pub fn is_launchable(&self) -> bool {
        self.conflicts.is_empty()
    }

    pub fn complete_environment_removals() -> BTreeSet<String> {
        MANAGED_CLAUDE_ENVIRONMENT_REMOVALS_V1
            .into_iter()
            .map(str::to_owned)
            .collect()
    }
}

/// One prepared managed Claude process. The private overlay remains owned until this value is
/// dropped, so both the interactive CLI and the bounded Live executor use the same routing,
/// credential-destination and cleanup boundary.
pub struct ManagedClaudeProcessV1 {
    command: Command,
    _overlay: TemporaryLaunchOverlay,
    #[cfg(windows)]
    _native_files: Vec<File>,
}

impl ManagedClaudeProcessV1 {
    pub fn prepare(
        descriptor: &ManagedClaudeLaunchDescriptorV2,
        user_settings: &Value,
        child_arguments: &[OsString],
        trusted_hiroute_executable: &str,
    ) -> Result<Self, ManagedClaudeProcessError> {
        descriptor
            .validate()
            .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
        if !Path::new(trusted_hiroute_executable).is_absolute() {
            return Err(ManagedClaudeProcessError::Unavailable);
        }
        #[cfg(not(windows))]
        let descriptor = {
            let trusted = std::fs::canonicalize(trusted_hiroute_executable)
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            let helper = std::fs::canonicalize(&descriptor.helper_executable)
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            if !helper.is_file() {
                return Err(ManagedClaudeProcessError::Unavailable);
            }
            // Unix installer-owned stable symlinks retain their existing meaning.
            let mut descriptor = descriptor.clone();
            descriptor.helper_executable = helper
                .to_str()
                .ok_or(ManagedClaudeProcessError::Unavailable)?
                .to_owned();
            descriptor
                .validate_trusted_helper(
                    trusted
                        .to_str()
                        .ok_or(ManagedClaudeProcessError::Unavailable)?,
                )
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            verify_claude_executable(&descriptor)?;
            descriptor
        };
        #[cfg(windows)]
        let (descriptor, native_files) =
            windows::prepare_paths(descriptor, Path::new(trusted_hiroute_executable))?;
        let overlay = TemporaryLaunchOverlay::create(&descriptor, user_settings)?;
        #[cfg(not(windows))]
        let mut command = Command::new(&descriptor.executable);
        #[cfg(windows)]
        let mut command = {
            let search = std::env::var_os("PATH")
                .unwrap_or_default()
                .into_string()
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            let (binary, prefix) = super::windows_runtime::windows_agent_command(
                Path::new(&descriptor.executable),
                &[],
                &search,
            )
            .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            let mut command = Command::new(binary);
            command.args(prefix);
            command
        };
        configure_command(&mut command, &descriptor, overlay.path(), child_arguments);
        Ok(Self {
            command,
            _overlay: overlay,
            #[cfg(windows)]
            _native_files: native_files,
        })
    }

    pub fn command_mut(&mut self) -> &mut Command {
        &mut self.command
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ManagedClaudeProcessError {
    Unavailable,
}

fn configure_command(
    command: &mut Command,
    descriptor: &ManagedClaudeLaunchDescriptorV2,
    overlay: &Path,
    child_arguments: &[OsString],
) {
    for name in &descriptor.environment_removals {
        command.env_remove(name);
        if !matches!(name.as_str(), "ANTHROPIC_BASE_URL" | "ANTHROPIC_MODEL") {
            command.env(name, "");
        }
    }
    for name in [
        "ANTHROPIC_DEFAULT_OPUS_MODEL",
        "ANTHROPIC_DEFAULT_SONNET_MODEL",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
    ] {
        command.env_remove(name);
    }
    command.env("ANTHROPIC_BASE_URL", &descriptor.gateway_base_url);
    if let Some(opus) = &descriptor.presets.opus {
        command.env("ANTHROPIC_DEFAULT_OPUS_MODEL", opus);
    }
    if let Some(sonnet) = &descriptor.presets.sonnet {
        command.env("ANTHROPIC_DEFAULT_SONNET_MODEL", sonnet);
    }
    if let Some(haiku) = &descriptor.presets.haiku {
        command.env("ANTHROPIC_DEFAULT_HAIKU_MODEL", haiku);
    }
    if let Some(window) = descriptor.context_window_tokens {
        for key in hiroute_domain::CLAUDE_CONTEXT_CONFLICT_ENVIRONMENT {
            command.env_remove(key);
        }
        command.envs(hiroute_domain::claude_context_environment(window).expect("validated window"));
    }
    command
        .arg(MANAGED_CLAUDE_SETTINGS_ARGUMENT_V1)
        .arg(overlay)
        .args(child_arguments);
}

#[cfg(not(windows))]
fn verify_claude_executable(
    descriptor: &ManagedClaudeLaunchDescriptorV2,
) -> Result<(), ManagedClaudeProcessError> {
    let canonical = std::fs::canonicalize(&descriptor.executable)
        .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
    if canonical.as_os_str() != OsStr::new(&descriptor.executable) {
        return Err(ManagedClaudeProcessError::Unavailable);
    }
    let metadata = canonical
        .metadata()
        .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
    if !metadata.is_file() {
        return Err(ManagedClaudeProcessError::Unavailable);
    }
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        if metadata.permissions().mode() & 0o111 == 0 {
            return Err(ManagedClaudeProcessError::Unavailable);
        }
    }
    Ok(())
}

struct TemporaryLaunchOverlay {
    directory: PathBuf,
    path: PathBuf,
    #[cfg(windows)]
    _root: super::probe_files::PrivateProbeRoot,
}

impl TemporaryLaunchOverlay {
    fn create(
        descriptor: &ManagedClaudeLaunchDescriptorV2,
        user_settings: &Value,
    ) -> Result<Self, ManagedClaudeProcessError> {
        #[cfg(windows)]
        {
            let root = super::probe_files::temporary("hiroute-claude-launch-")
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            let directory = root.path().to_owned();
            let path = directory.join("settings.json");
            let mut file = super::probe_files::file(&path)
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            write_overlay(&mut file, descriptor, user_settings)?;
            file.sync_all()
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            drop(file);
            Ok(Self {
                directory,
                path,
                _root: root,
            })
        }
        #[cfg(not(any(unix, windows)))]
        {
            let _ = (descriptor, user_settings);
            return Err(ManagedClaudeProcessError::Unavailable);
        }
        #[cfg(unix)]
        {
            use std::os::unix::fs::{DirBuilderExt, OpenOptionsExt, PermissionsExt};

            let root = std::env::temp_dir();
            let mut directory = None;
            for _ in 0..32 {
                let mut entropy = [0_u8; 16];
                getrandom::fill(&mut entropy)
                    .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
                let candidate = root.join(format!(
                    "hiroute-claude-launch-{:032x}",
                    u128::from_ne_bytes(entropy)
                ));
                let mut builder = std::fs::DirBuilder::new();
                builder.mode(0o700);
                match builder.create(&candidate) {
                    Ok(()) => {
                        directory = Some(candidate);
                        break;
                    }
                    Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
                    Err(_) => return Err(ManagedClaudeProcessError::Unavailable),
                }
            }
            let directory = directory.ok_or(ManagedClaudeProcessError::Unavailable)?;
            let path = directory.join("settings.json");
            let overlay = Self { directory, path };
            std::fs::set_permissions(&overlay.directory, std::fs::Permissions::from_mode(0o700))
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            let mut options = OpenOptions::new();
            options.write(true).create_new(true).mode(0o600);
            let mut file = options
                .open(&overlay.path)
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            write_overlay(&mut file, descriptor, user_settings)?;
            file.sync_all()
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            std::fs::set_permissions(&overlay.path, std::fs::Permissions::from_mode(0o600))
                .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
            Ok(overlay)
        }
    }

    fn path(&self) -> &Path {
        &self.path
    }
}

impl Drop for TemporaryLaunchOverlay {
    fn drop(&mut self) {
        let _ = std::fs::remove_file(&self.path);
        let _ = std::fs::remove_dir(&self.directory);
    }
}

fn write_overlay(
    file: &mut File,
    descriptor: &ManagedClaudeLaunchDescriptorV2,
    user_settings: &Value,
) -> Result<(), ManagedClaudeProcessError> {
    #[cfg(not(windows))]
    let helper_command = {
        let mut components = Vec::with_capacity(1 + descriptor.helper_argv.len());
        components.push(descriptor.helper_executable.as_str());
        components.extend(descriptor.helper_argv.iter().map(String::as_str));
        components
            .into_iter()
            .map(shell_quote)
            .collect::<Vec<_>>()
            .join(" ")
    };
    #[cfg(windows)]
    let helper_command = hiroute_platform::windows::launcher::managed_helper_command(
        Path::new(&descriptor.helper_executable),
        &descriptor.helper_argv,
    )
    .map_err(|_| ManagedClaudeProcessError::Unavailable)?;
    let mut overlay = match user_settings {
        Value::Object(fields) => fields.clone(),
        _ => Map::new(),
    };
    overlay.remove("apiKeyHelper");
    let mut env = overlay
        .remove("env")
        .and_then(|value| value.as_object().cloned())
        .unwrap_or_default();
    for name in MANAGED_CLAUDE_ENVIRONMENT {
        #[cfg(windows)]
        env.retain(|key, _| !key.eq_ignore_ascii_case(name));
        #[cfg(not(windows))]
        env.remove(name);
    }
    let mut managed_env = Map::new();
    for name in &descriptor.environment_removals {
        if !matches!(name.as_str(), "ANTHROPIC_BASE_URL" | "ANTHROPIC_MODEL") {
            managed_env.insert(name.clone(), json!(""));
        }
    }
    managed_env.insert(
        "ANTHROPIC_BASE_URL".to_owned(),
        json!(descriptor.gateway_base_url),
    );
    for (name, value) in [
        ("ANTHROPIC_DEFAULT_OPUS_MODEL", &descriptor.presets.opus),
        ("ANTHROPIC_DEFAULT_SONNET_MODEL", &descriptor.presets.sonnet),
        ("ANTHROPIC_DEFAULT_HAIKU_MODEL", &descriptor.presets.haiku),
    ] {
        managed_env.insert(name.to_owned(), json!(value.as_deref().unwrap_or("")));
    }
    for (name, value) in managed_env {
        env.insert(name, value);
    }
    if let Some(window) = descriptor.context_window_tokens {
        for key in hiroute_domain::CLAUDE_CONTEXT_CONFLICT_ENVIRONMENT {
            env.remove(key);
        }
        for (key, value) in
            hiroute_domain::claude_context_environment(window).expect("validated window")
        {
            env.insert(key, json!(value));
        }
    }
    overlay.insert("env".to_owned(), Value::Object(env));
    overlay.insert("apiKeyHelper".to_owned(), json!(helper_command));
    serde_json::to_writer(file, &Value::Object(overlay))
        .map_err(|_| ManagedClaudeProcessError::Unavailable)
}

#[cfg(not(windows))]
fn shell_quote(value: &str) -> String {
    format!("'{}'", value.replace('\'', "'\\''"))
}

const MANAGED_CLAUDE_ENVIRONMENT: [&str; 11] = [
    "ANTHROPIC_API_KEY",
    "ANTHROPIC_AUTH_TOKEN",
    "ANTHROPIC_BASE_URL",
    "ANTHROPIC_CUSTOM_HEADERS",
    "ANTHROPIC_MODEL",
    "ANTHROPIC_DEFAULT_OPUS_MODEL",
    "ANTHROPIC_DEFAULT_SONNET_MODEL",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
    "CLAUDE_CODE_USE_BEDROCK",
    "CLAUDE_CODE_USE_FOUNDRY",
    "CLAUDE_CODE_USE_VERTEX",
];

#[cfg(test)]
mod context_window_tests {
    use super::*;

    #[test]
    fn managed_claude_context_window_overrides_caller_settings_and_process_environment() {
        let mut descriptor = ManagedClaudeLaunchDescriptorV2::trusted(
            "agent-connection/context-test",
            "claude-messages-v1",
            crate::agents::test_absolute_path("/trusted/claude")
                .to_str()
                .unwrap(),
            hiroute_domain::CanonicalDigest::of_bytes(b"snapshot"),
            1,
            hiroute_domain::CanonicalDigest::of_bytes(b"publication"),
            "http://127.0.0.1:4321",
            hiroute_domain::AgentClaudePresetValuesV2 {
                opus: Some("hiroute-plan".into()),
                sonnet: None,
                haiku: None,
            },
            crate::agents::test_absolute_path("/trusted/hiroute")
                .to_str()
                .unwrap(),
        )
        .unwrap();
        descriptor.context_window_tokens = Some(272_000);
        descriptor.validate().unwrap();
        let file = tempfile::NamedTempFile::new().unwrap();
        write_overlay(&mut file.reopen().unwrap(), &descriptor, &json!({"theme":"dark", "env":{"DISABLE_COMPACT":"1", "CLAUDE_CODE_AUTO_COMPACT_WINDOW":"900000", "UNRELATED":"keep"}})).unwrap();
        let overlay: Value = serde_json::from_reader(file.reopen().unwrap()).unwrap();
        assert_eq!(overlay["theme"], "dark");
        assert_eq!(overlay["env"]["UNRELATED"], "keep");
        assert_eq!(overlay["env"]["CLAUDE_CODE_AUTO_COMPACT_WINDOW"], "272000");
        assert_eq!(overlay["env"]["CLAUDE_CODE_MAX_CONTEXT_TOKENS"], "272000");
        assert!(overlay["env"].get("DISABLE_COMPACT").is_none());
        let mut command = Command::new(crate::agents::test_absolute_path("/trusted/claude"));
        configure_command(&mut command, &descriptor, file.path(), &[]);
        let environment: std::collections::BTreeMap<_, _> = command.get_envs().collect();
        assert_eq!(
            environment[OsStr::new("CLAUDE_CODE_AUTO_COMPACT_WINDOW")],
            Some(OsStr::new("272000"))
        );
        assert_eq!(environment[OsStr::new("DISABLE_COMPACT")], None);
    }
}