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.

4.2 KB
Raw Blame
//! OS-trusted credential minting. A collaboration grant can never enter this path.
use super::auth::{AuthError, ConsoleAuth, LaunchTarget};
use hiroute_application_api::*;
use serde_json::{Value, json};
use std::{
    path::Path,
    sync::{Arc, Mutex, OnceLock},
};

pub trait ConsoleEndpoint: Send + Sync {
    fn launch_target(&self, loopback_only: bool) -> Result<LaunchTarget, AuthError>;
}
pub struct ConsoleControl {
    pub(super) auth: Arc<Mutex<ConsoleAuth>>,
    endpoint: OnceLock<Arc<dyn ConsoleEndpoint>>,
}
impl ConsoleControl {
    pub fn open(data_root: &Path) -> Result<Self, AuthError> {
        Ok(Self {
            auth: Arc::new(Mutex::new(ConsoleAuth::open(data_root)?)),
            endpoint: OnceLock::new(),
        })
    }
    pub fn set_endpoint(&self, endpoint: Arc<dyn ConsoleEndpoint>) -> Result<(), AuthError> {
        self.endpoint
            .set(endpoint)
            .map_err(|_| AuthError::Unavailable)
    }
    pub(crate) fn dispatch(
        &self,
        request: &LocalControlWireRequestV2,
    ) -> Option<MachineEnvelopeV2<Value>> {
        if !matches!(
            request.operation_id.as_str(),
            "CreateConsoleLaunch"
                | "CreateConsoleToken"
                | "ListConsoleTokens"
                | "RevokeConsoleToken"
        ) {
            return None;
        }
        let result = if request.protected_grant.is_some() {
            Err(ErrorCode::CapabilityDenied)
        } else {
            self.execute(request).map_err(|e| match e {
                AuthError::Invalid => ErrorCode::InvalidArguments,
                AuthError::ListenerUnavailable => ErrorCode::ActionRequired,
                _ => ErrorCode::DaemonUnavailable,
            })
        };
        Some(match result {
            Ok(data) => MachineEnvelopeV2::succeeded(data, Some(request.request_id.clone())),
            Err(code) => {
                MachineEnvelopeV2::failed(ErrorV1::new(code), Some(request.request_id.clone()))
            }
        })
    }
    fn execute(&self, request: &LocalControlWireRequestV2) -> Result<Value, AuthError> {
        match request.operation_id.as_str() {
            "CreateConsoleLaunch" => {
                let input: ConsoleLaunchRequestV1 = serde_json::from_value(request.payload.clone())
                    .map_err(|_| AuthError::Invalid)?;
                let target = self
                    .endpoint
                    .get()
                    .ok_or(AuthError::Unavailable)?
                    .launch_target(input.loopback_only)?;
                let url = target.origin.clone();
                let code = self
                    .auth
                    .lock()
                    .map_err(|_| AuthError::Unavailable)?
                    .create_launch(target)?;
                Ok(json!({"url":format!("{url}/launch?code={}", code.as_str()),"expires_in":120}))
            }
            "CreateConsoleToken" => {
                let input: ConsoleCreateTokenRequestV1 =
                    serde_json::from_value(request.payload.clone())
                        .map_err(|_| AuthError::Invalid)?;
                let created = self
                    .auth
                    .lock()
                    .map_err(|_| AuthError::Unavailable)?
                    .create_token(input.name, input.expires_days)?;
                serde_json::to_value(created).map_err(|_| AuthError::Unavailable)
            }
            "ListConsoleTokens" => {
                let _: ConsoleListTokensRequestV1 = serde_json::from_value(request.payload.clone())
                    .map_err(|_| AuthError::Invalid)?;
                Ok(
                    json!({"tokens":self.auth.lock().map_err(|_|AuthError::Unavailable)?.list_tokens()}),
                )
            }
            "RevokeConsoleToken" => {
                let input: ConsoleRevokeTokenRequestV1 =
                    serde_json::from_value(request.payload.clone())
                        .map_err(|_| AuthError::Invalid)?;
                self.auth
                    .lock()
                    .map_err(|_| AuthError::Unavailable)?
                    .revoke_token(&input.id)?;
                Ok(json!({"revoked":true}))
            }
            _ => Err(AuthError::Invalid),
        }
    }
}