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.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
use crate::{ConsoleOrigin, startup_failure};
use serde::Serialize;
use std::sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
};
use tauri::{Manager, WebviewUrl, WebviewWindow, WebviewWindowBuilder, WindowEvent};
mod commands;
mod install_transaction;
pub mod installer;
mod service;
mod tray;
mod updater;
use commands::*;
#[derive(Clone, Serialize)]
pub struct Status {
phase: &'static str,
code: Option<&'static str>,
logs_path: String,
storage_recovery: Option<hiroute_host_runtime::StorageRecovery>,
}
pub struct ShellState {
origin: Mutex<Option<ConsoleOrigin>>,
status: Mutex<Status>,
starting: AtomicBool,
updater: updater::Updater,
}
impl ShellState {
fn new() -> Self {
let logs = hiroute_host_runtime::StandaloneLayout::from_environment()
.ok()
.map(|l| l.diagnostics_root().display().to_string())
.unwrap_or_default();
Self {
origin: Mutex::new(None),
status: Mutex::new(Status {
phase: "starting",
code: None,
logs_path: logs,
storage_recovery: None,
}),
starting: AtomicBool::new(false),
updater: updater::Updater::new(),
}
}
fn phase(&self, phase: &'static str, code: Option<&'static str>) {
if let Ok(mut status) = self.status.lock() {
status.phase = phase;
status.code = code;
status.storage_recovery = None;
}
}
fn failed(&self, failure: startup_failure::Failure) {
if let Ok(mut status) = self.status.lock() {
status.phase = "failed";
status.code = Some(failure.code);
status.storage_recovery = failure.recovery;
}
}
}
fn focus(app: &tauri::AppHandle) {
if let Some(window) = app.get_webview_window("main") {
let _ = window.show();
let _ = window.unminimize();
let _ = window.set_focus();
}
}
fn start(app: tauri::AppHandle, state: Arc<ShellState>) {
if state.starting.swap(true, Ordering::AcqRel) {
return;
}
state.phase("starting", None);
tauri::async_runtime::spawn(async move {
let outcome = async {
let (origin, url) = service::ready_launch(&state).await?;
*state.origin.lock().map_err(|_| "SHELL_STATE_UNAVAILABLE")? = Some(origin);
let window = app
.get_webview_window("main")
.ok_or("SHELL_WINDOW_UNAVAILABLE")?;
window
.navigate(url)
.map_err(|_| "SHELL_NAVIGATION_FAILED")?;
state.phase("ready", None);
Ok::<_, startup_failure::Failure>(())
}
.await;
if let Err(failure) = outcome {
state.failed(failure);
focus(&app);
}
state.starting.store(false, Ordering::Release);
});
}
fn local_status(url: &url::Url) -> bool {
((url.scheme() == "tauri" && url.host_str() == Some("localhost"))
|| (url.scheme() == "http" && url.host_str() == Some("tauri.localhost")))
&& matches!(url.path(), "/" | "/index.html")
}
fn authorize(window: &WebviewWindow, state: &ShellState) -> Result<(), &'static str> {
let url = window.url().map_err(|_| "SHELL_ORIGIN_DENIED")?;
if window.label() != "main"
|| !state
.origin
.lock()
.map_err(|_| "SHELL_STATE_UNAVAILABLE")?
.as_ref()
.is_some_and(|o| o.allows(&url))
{
return Err("SHELL_ORIGIN_DENIED");
}
Ok(())
}
fn authorize_status(window: &WebviewWindow) -> Result<(), &'static str> {
if window.label() != "main" || !local_status(&window.url().map_err(|_| "SHELL_ORIGIN_DENIED")?)
{
return Err("SHELL_ORIGIN_DENIED");
}
Ok(())
}
pub fn run() {
if hiroute_platform::windows::install::require_x64().is_err() {
return;
}
let state = Arc::new(ShellState::new());
let tray_enabled = installer::tray_enabled();
let background = tray_enabled && std::env::args_os().any(|arg| arg == "--background");
let outcome = tauri::Builder::default()
.plugin(tauri_plugin_single_instance::init(|app, _, _| focus(app)))
.plugin(tauri_plugin_dialog::init())
.manage(state.clone())
.invoke_handler(tauri::generate_handler![
shell_status,
shell_retry_startup,
shell_capabilities,
shell_open_in_browser,
shell_open_external_url,
shell_save_classifier_openapi,
shell_login_start_get,
shell_login_start_set,
shell_restart_service,
shell_reconnect,
shell_update_status,
shell_update_check,
shell_update_download,
shell_update_install,
shell_update_cancel
])
.on_window_event(move |window, event| {
if window.label() == "main"
&& let WindowEvent::CloseRequested { api, .. } = event
{
if tray_enabled {
api.prevent_close();
let _ = window.hide();
} else {
window.app_handle().exit(0);
}
}
})
.setup(move |app| {
let navigation = state.clone();
WebviewWindowBuilder::new(app, "main", WebviewUrl::App("index.html".into()))
.title("HiRoute")
.inner_size(1200., 813.)
.min_inner_size(755., 600.)
.visible(!background)
.incognito(true)
.initialization_script(
"Object.defineProperty(window,'__HIROUTE_SHELL__',{value:true});",
)
.on_navigation(move |url| {
if local_status(url)
|| navigation
.origin
.lock()
.ok()
.and_then(|o| o.clone())
.is_some_and(|o| o.allows(url))
{
return true;
}
if let Ok(url) = crate::external_url(url.as_str()) {
let _ = hiroute_platform::windows::shell_open::url(url.as_str());
}
false
})
.on_new_window(|url, _| {
if let Ok(url) = crate::external_url(url.as_str()) {
let _ = hiroute_platform::windows::shell_open::url(url.as_str());
}
tauri::webview::NewWindowResponse::Deny
})
.build()?;
if tray_enabled {
tray::create(app)?;
}
match updater::recover_startup(app.handle(), &state, false) {
Ok(true) => {}
Ok(false) => start(app.handle().clone(), state.clone()),
Err(code) => {
state.phase("failed", Some(code));
focus(app.handle());
}
}
Ok(())
})
.run(tauri::generate_context!());
if outcome.is_err() {
hiroute_platform::windows::shell_open::startup_failure();
}
}
pub fn run_helper() -> Option<i32> {
updater::run_if_requested().or_else(installer::run_if_requested)
}