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.

15.7 KB
Raw Blame
#[cfg(windows)]
use hiroute_platform::windows::pipe::{Listener as LocalListener, Stream as LocalStream};
#[cfg(unix)]
use std::io::{Read, Write};
#[cfg(all(test, unix))]
use std::os::unix::net::{UnixListener, UnixStream};
#[cfg(unix)]
use std::os::unix::net::{UnixListener as LocalListener, UnixStream as LocalStream};
use std::path::{Path, PathBuf};
#[cfg(unix)]
use std::sync::mpsc::{self, Receiver};
use std::time::Duration;

use hiroute_application_api::{
    STANDALONE_PROTECTED_INPUT_MAX_FRAME_BYTES_V1, STANDALONE_PROTECTED_INPUT_REQUEST_SCHEMA_V1,
    STANDALONE_PROTECTED_INPUT_RESPONSE_SCHEMA_V1, StandaloneProtectedInputRequestV1,
    StandaloneProtectedInputResponseV1,
};
use hiroute_domain::ProtectedSecret;
use hiroute_host_runtime::StandaloneLayout;
use zeroize::{Zeroize, Zeroizing};

const IO_TIMEOUT: Duration = Duration::from_secs(2);

mod bootstrap;
pub(super) use bootstrap::{apply_standalone_defaults, run_all_standalone};

#[cfg(windows)]
mod windows;

/// Local credential input shared by standalone and Desktop-owned role-all processes.
pub(super) struct ProtectedInputServer {
    listener: LocalListener,
    #[cfg(unix)]
    path: PathBuf,
    #[cfg(windows)]
    lifecycle: Option<windows::LifecycleServer>,
    #[cfg(windows)]
    shutdown: Option<std::sync::mpsc::Receiver<()>>,
}

impl ProtectedInputServer {
    pub(super) fn bind(layout: &StandaloneLayout) -> Result<Self, String> {
        let server = Self::bind_path(layout.protected_input_socket())?;
        #[cfg(windows)]
        let server = {
            let mut server = server;
            server.lifecycle = Some(windows::LifecycleServer::bind(layout)?);
            // Register console shutdown before publishing the daemon readiness frame.
            server.shutdown = Some(windows::shutdown_signal()?);
            server
        };
        Ok(server)
    }

    pub(super) fn bind_path(path: PathBuf) -> Result<Self, String> {
        let parent = path
            .parent()
            .ok_or("protected input socket parent is unavailable")?;
        validate_private_directory(parent)?;
        remove_stale_socket(&path)?;
        let listener =
            LocalListener::bind(&path).map_err(|_| "protected input socket bind failed")?;
        #[cfg(unix)]
        {
            use std::os::unix::fs::PermissionsExt;
            std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600))
                .map_err(|_| "protected input socket permissions failed")?;
        }
        listener
            .set_nonblocking(true)
            .map_err(|_| "protected input socket setup failed")?;
        Ok(Self {
            listener,
            #[cfg(unix)]
            path,
            #[cfg(windows)]
            lifecycle: None,
            #[cfg(windows)]
            shutdown: None,
        })
    }

    pub(super) fn poll(&self, role: &hiroute_daemon::RoleAllHandle) -> Result<(), String> {
        match self.listener.accept() {
            Ok((stream, _)) => {
                // Reject one malformed/unauthorized request without stopping the service.
                let _ = handle_connection(role, stream);
                Ok(())
            }
            Err(error)
                if matches!(
                    error.kind(),
                    std::io::ErrorKind::WouldBlock | std::io::ErrorKind::Interrupted
                ) =>
            {
                Ok(())
            }
            Err(_) => Err("protected input socket accept failed".into()),
        }
    }

    pub(super) fn run(
        #[allow(unused_mut)] mut self,
        mut role: hiroute_daemon::RoleAllHandle,
        mut console: Option<hiroute_daemon::console::ConsoleService>,
        #[cfg(windows)] service: Option<hiroute_platform::windows::service::ServiceShutdown>,
    ) -> Result<(), String> {
        let result = (|| {
            #[cfg(unix)]
            let shutdown = Some(shutdown_signal()?);
            #[cfg(windows)]
            let shutdown = if service.is_some() {
                None
            } else {
                Some(
                    self.shutdown
                        .take()
                        .ok_or("standalone signal handler unavailable")?,
                )
            };
            loop {
                #[cfg(windows)]
                if service
                    .as_ref()
                    .is_some_and(|service| service.is_requested())
                {
                    break Ok(());
                }
                #[cfg(windows)]
                if let Some(server) = self.lifecycle.as_ref()
                    && server.poll_stop(&role)?
                {
                    break Ok(());
                }
                if shutdown
                    .as_ref()
                    .is_some_and(|shutdown| shutdown.try_recv().is_ok())
                {
                    break Ok(());
                }
                self.poll(&role)?;
                std::thread::sleep(Duration::from_millis(20));
            }
        })();
        if let Some(console) = console.as_mut() {
            console.shutdown();
        }
        role.shutdown();
        let joined = role
            .join(Duration::from_secs(30))
            .map_err(|error| error.to_string());
        result.and(joined)
    }
}

impl Drop for ProtectedInputServer {
    fn drop(&mut self) {
        #[cfg(unix)]
        let _ = std::fs::remove_file(&self.path);
    }
}

fn handle_connection(
    role: &hiroute_daemon::RoleAllHandle,
    mut stream: LocalStream,
) -> Result<(), String> {
    stream
        .set_read_timeout(Some(IO_TIMEOUT))
        .map_err(|_| "protected input read timeout setup failed")?;
    stream
        .set_write_timeout(Some(IO_TIMEOUT))
        .map_err(|_| "protected input write timeout setup failed")?;
    #[cfg(windows)]
    stream
        .set_deadline(Some(std::time::Instant::now() + IO_TIMEOUT))
        .map_err(|_| "protected input deadline setup failed")?;
    #[cfg(unix)]
    let mut bytes = Zeroizing::new(Vec::new());
    #[cfg(unix)]
    Read::by_ref(&mut stream)
        .take(STANDALONE_PROTECTED_INPUT_MAX_FRAME_BYTES_V1 + 1)
        .read_to_end(&mut bytes)
        .map_err(|_| "protected input request read failed")?;
    #[cfg(windows)]
    let bytes = hiroute_platform::local_record::read(
        &mut stream,
        hiroute_platform::local_record::Channel::ProtectedInput,
        hiroute_platform::local_record::Direction::Request,
        STANDALONE_PROTECTED_INPUT_MAX_FRAME_BYTES_V1 as usize,
    )
    .map_err(|_| "protected input request read failed")?;
    if bytes.is_empty() || bytes.len() as u64 > STANDALONE_PROTECTED_INPUT_MAX_FRAME_BYTES_V1 {
        return Err("protected input request size is invalid".into());
    }
    let mut request: StandaloneProtectedInputRequestV1 =
        serde_json::from_slice(&bytes).map_err(|_| "protected input request is invalid")?;
    if request.schema != STANDALONE_PROTECTED_INPUT_REQUEST_SCHEMA_V1 {
        return Err("protected input request schema is invalid".into());
    }
    match request.action.as_str() {
        "register" => {
            if request.candidate_revision != Some(1) {
                return Err("protected input request is invalid".into());
            }
            let candidate_ref = request
                .candidate_ref
                .take()
                .filter(|value| valid_candidate_ref(value))
                .ok_or("protected input candidate is invalid")?;
            let mut secret = request.secret.take().ok_or("protected input is missing")?;
            if secret.is_empty() || secret.len() > 32 * 1024 {
                secret.zeroize();
                return Err("protected input is invalid".into());
            }
            let protected = ProtectedSecret::new(secret.as_bytes().to_vec())
                .map_err(|_| "protected input is invalid")?;
            secret.zeroize();
            role.register_manual_protected_input(
                hiroute_application_api::ComputeCandidateRefV2 {
                    candidate_ref: candidate_ref.clone(),
                    candidate_revision: 1,
                },
                protected,
            )?;
            let response = write_response(
                &mut stream,
                &StandaloneProtectedInputResponseV1 {
                    schema: STANDALONE_PROTECTED_INPUT_RESPONSE_SCHEMA_V1.into(),
                    action: "register".into(),
                    registered: true,
                },
            );
            if response.is_err() {
                let _ = role.release_manual_protected_input(&candidate_ref);
            }
            response?;
            response_acknowledgement(&mut stream)
        }
        "release" => {
            if request.candidate_revision.is_some() || request.secret.is_some() {
                return Err("protected input release is invalid".into());
            }
            let candidate_ref = request
                .candidate_ref
                .take()
                .filter(|value| valid_candidate_ref(value))
                .ok_or("protected input candidate is invalid")?;
            role.release_manual_protected_input(&candidate_ref)?;
            write_response(
                &mut stream,
                &StandaloneProtectedInputResponseV1 {
                    schema: STANDALONE_PROTECTED_INPUT_RESPONSE_SCHEMA_V1.into(),
                    action: "release".into(),
                    registered: true,
                },
            )?;
            response_acknowledgement(&mut stream)
        }
        _ => Err("protected input action is invalid".into()),
    }
}

fn write_response(
    stream: &mut LocalStream,
    response: &StandaloneProtectedInputResponseV1,
) -> Result<(), String> {
    let bytes = Zeroizing::new(
        serde_json::to_vec(response).map_err(|_| "protected input response is invalid")?,
    );
    #[cfg(unix)]
    {
        let mut bytes = bytes;
        bytes.push(b'\n');
        stream
            .write_all(&bytes)
            .and_then(|_| stream.flush())
            .map_err(|_| "protected input response write failed".into())
    }
    #[cfg(windows)]
    hiroute_platform::local_record::write(
        stream,
        hiroute_platform::local_record::Channel::ProtectedInput,
        hiroute_platform::local_record::Direction::Response,
        &bytes,
        STANDALONE_PROTECTED_INPUT_MAX_FRAME_BYTES_V1 as usize,
    )
    .map_err(|_| "protected input response write failed".into())
}

fn response_acknowledgement(stream: &mut LocalStream) -> Result<(), String> {
    #[cfg(unix)]
    let _ = stream;
    #[cfg(windows)]
    hiroute_platform::local_record::await_acknowledgement(stream)
        .map_err(|_| "protected input response acknowledgement failed")?;
    // An absent ACK cannot revoke a registration whose successful response
    // may already have been read. The caller can release it explicitly.
    Ok(())
}

fn valid_candidate_ref(value: &str) -> bool {
    !value.is_empty()
        && value.len() <= 256
        && value.bytes().all(|byte| {
            byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-' | b'/' | b':')
        })
}

fn validate_private_directory(path: &Path) -> Result<(), String> {
    #[cfg(windows)]
    return hiroute_platform::windows::security::open_owner_only(path, true)
        .map(|_| ())
        .map_err(|_| "protected input socket directory is unsafe".into());
    #[cfg(unix)]
    {
        let metadata = std::fs::symlink_metadata(path)
            .map_err(|_| "protected input socket directory is unavailable")?;
        if !metadata.is_dir() || metadata.file_type().is_symlink() {
            return Err("protected input socket directory is unsafe".into());
        }
        Ok(())
    }
}

#[cfg(unix)]
fn remove_stale_socket(path: &Path) -> Result<(), String> {
    use std::os::unix::fs::FileTypeExt;
    match std::fs::symlink_metadata(path) {
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => Ok(()),
        Err(_) => Err("protected input socket state is unavailable".into()),
        Ok(metadata) if metadata.file_type().is_socket() => std::fs::remove_file(path)
            .map_err(|_| "protected input stale socket cannot be removed".into()),
        Ok(_) => Err("protected input socket path conflicts with another entry".into()),
    }
}

#[cfg(windows)]
fn remove_stale_socket(path: &Path) -> Result<(), String> {
    // The logical locator never becomes a filesystem socket on Windows.
    if std::fs::symlink_metadata(path).is_ok() {
        return Err("protected input socket path conflicts with another entry".into());
    }
    Ok(())
}

#[cfg(unix)]
fn shutdown_signal() -> Result<Receiver<()>, String> {
    let (sender, receiver) = mpsc::sync_channel(1);
    std::thread::Builder::new()
        .name("hiroute-standalone-signals".into())
        .spawn(move || {
            use tokio::signal::unix::{SignalKind, signal};
            let Ok(runtime) = tokio::runtime::Builder::new_current_thread()
                .enable_io()
                .build()
            else {
                return;
            };
            runtime.block_on(async move {
                let (Ok(mut terminate), Ok(mut interrupt)) = (
                    signal(SignalKind::terminate()),
                    signal(SignalKind::interrupt()),
                ) else {
                    return;
                };
                tokio::select! {
                    _ = terminate.recv() => {}
                    _ = interrupt.recv() => {}
                }
                let _ = sender.try_send(());
            });
        })
        .map_err(|_| "standalone signal handler unavailable")?;
    Ok(receiver)
}

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

    #[test]
    fn protocol_rejects_authority_fields_and_invalid_candidate_shapes() {
        assert!(valid_candidate_ref("candidate/manual:one"));
        assert!(!valid_candidate_ref("candidate with spaces"));
        let request: Result<StandaloneProtectedInputRequestV1, _> = serde_json::from_slice(
            br#"{"schema":"hiroute.standalone-protected-input-request/v1","action":"register","candidate_ref":"candidate/manual","candidate_revision":1,"secret":"x","operation_kind":"ApplyAgentPlanChange"}"#,
        );
        assert!(request.is_err());
    }

    #[test]
    fn stale_socket_cleanup_refuses_regular_files() {
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().join("protected-input.sock");
        std::fs::write(&path, b"unrelated").unwrap();
        assert!(remove_stale_socket(&path).is_err());
        assert_eq!(std::fs::read(&path).unwrap(), b"unrelated");
    }

    #[test]
    #[cfg(unix)]
    fn protected_input_fits_a_runtime_root_that_supports_local_control() {
        use std::os::unix::fs::PermissionsExt;

        let directory = tempfile::tempdir_in(std::fs::canonicalize("/tmp").unwrap()).unwrap();
        let prefix = directory.path().as_os_str().as_encoded_bytes().len();
        // control.sock fits macOS's 104-byte sockaddr_un including the trailing NUL.
        // The old protected-input-v1.sock name exceeded it in ordinary Desktop roots.
        let runtime = directory.path().join("r".repeat(82 - prefix - 1));
        let private = runtime.join("hiroute");
        std::fs::create_dir_all(&private).unwrap();
        std::fs::set_permissions(&private, std::fs::Permissions::from_mode(0o700)).unwrap();
        let _control = UnixListener::bind(private.join("control.sock")).unwrap();
        let mut layout = StandaloneLayout::from_values(
            true,
            Some(directory.path().to_owned()),
            None,
            None,
            None,
        )
        .unwrap();
        layout.runtime_root = runtime;
        let server = ProtectedInputServer::bind(&layout).unwrap();
        let _client = UnixStream::connect(layout.protected_input_socket()).unwrap();
        let (_peer, _) = server.listener.accept().unwrap();
        drop(server);
        assert!(!layout.protected_input_socket().exists());
    }
}