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
//! Native updater lifecycle. WebView chooses actions; source, paths and trust stay native.
use hiroute_host_runtime::{
DesktopPackageIdentity, DesktopRelease, UpgradeAction, verify_desktop_app,
};
use serde::Serialize;
use std::{
path::PathBuf,
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
},
};
use tauri::{Manager, State, WebviewWindow};
mod download;
mod installer;
pub use installer::finish_update_if_requested;
#[derive(Clone)]
struct PreparedUpdate {
release: DesktopRelease,
current: PathBuf,
staged: PathBuf,
download_root: PathBuf,
old_identity: DesktopPackageIdentity,
new_identity: DesktopPackageIdentity,
}
impl PreparedUpdate {
fn revalidate(&self) -> Result<(), String> {
if verify_desktop_app(&self.current, "ai.hiroute.desktop", None, None)? != self.old_identity
|| verify_desktop_app(
&self.staged,
"ai.hiroute.desktop",
Some(&self.release),
None,
)? != self.new_identity
{
return Err("UPGRADE_PACKAGE_CHANGED".into());
}
Ok(())
}
}
#[derive(Clone, Copy, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum UpdateRecovery {
ServiceAvailable,
StopPending,
RestartRequired,
}
#[derive(Clone, Serialize)]
pub struct UpdateView {
current_version: String,
phase: String,
available: Option<DesktopRelease>,
downloaded_bytes: u64,
active_calls: u64,
active_tasks: u64,
error: Option<String>,
can_install: bool,
package_ready: bool,
recovery: Option<UpdateRecovery>,
}
struct UpdateInner {
view: UpdateView,
prepared: Option<PreparedUpdate>,
}
pub struct Updates {
inner: Mutex<UpdateInner>,
cancelled: AtomicBool,
current_app: Option<PathBuf>,
data_root: Option<PathBuf>,
}
pub struct UpdateState(pub Arc<Updates>);
impl UpdateState {
pub fn new(current_version: String, data_root: Option<PathBuf>) -> Self {
let current_app = std::env::current_exe().ok().and_then(|p| {
(p.file_name()? == "hiroute-desktop"
&& p.parent()?.file_name()? == "MacOS"
&& p.parent()?.parent()?.file_name()? == "Contents")
.then(|| {
p.parent()
.unwrap()
.parent()
.unwrap()
.parent()
.unwrap()
.to_path_buf()
})
.and_then(|app| std::fs::canonicalize(app).ok())
});
let current_version = current_app
.as_ref()
.and_then(|app| {
let output = std::process::Command::new("/usr/bin/plutil")
.args(["-extract", "CFBundleShortVersionString", "raw", "-o", "-"])
.arg(app.join("Contents/Info.plist"))
.output()
.ok()?;
output
.status
.success()
.then(|| String::from_utf8_lossy(&output.stdout).trim().to_owned())
})
.unwrap_or(current_version);
Self(Arc::new(Updates {
inner: Mutex::new(UpdateInner {
view: UpdateView {
current_version,
phase: "idle".into(),
available: None,
downloaded_bytes: 0,
active_calls: 0,
active_tasks: 0,
error: None,
can_install: current_app.is_some(),
package_ready: false,
recovery: None,
},
prepared: None,
}),
cancelled: AtomicBool::new(false),
current_app,
data_root,
}))
}
}
impl Updates {
fn edit(&self, update: impl FnOnce(&mut UpdateView)) -> Result<(), String> {
update(
&mut self
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?
.view,
);
Ok(())
}
fn view(&self) -> Result<UpdateView, String> {
Ok(self
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?
.view
.clone())
}
fn begin(&self, phase: &str) -> Result<UpdateView, String> {
let mut inner = self.inner.lock().map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
if matches!(
inner.view.phase.as_str(),
"checking" | "downloading" | "verifying" | "waiting" | "installing"
) {
return Err("UPGRADE_BUSY".into());
}
self.cancelled.store(false, Ordering::SeqCst);
inner.view.phase = phase.into();
inner.view.error = None;
if matches!(inner.view.recovery, Some(UpdateRecovery::ServiceAvailable)) {
inner.view.recovery = None;
}
Ok(inner.view.clone())
}
fn fail(&self, error: String) {
let _ = self.edit(|v| {
v.phase = "failed".into();
v.error = Some(error);
});
}
}
fn main_window(window: &WebviewWindow) -> Result<(), String> {
if window.label() == "main" {
Ok(())
} else {
Err("WINDOW_DENIED".into())
}
}
#[tauri::command]
pub fn update_status(
window: WebviewWindow,
state: State<'_, UpdateState>,
) -> Result<UpdateView, String> {
main_window(&window)?;
state.0.view()
}
#[tauri::command]
pub async fn update_check(
window: WebviewWindow,
state: State<'_, UpdateState>,
) -> Result<UpdateView, String> {
main_window(&window)?;
let view = state.0.begin("checking")?;
let arch = if cfg!(target_arch = "aarch64") {
"arm64"
} else {
"x86_64"
};
match download::check(&view.current_version, arch).await {
Ok(release) => {
let mut inner = state
.0
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
let reusable = inner.prepared.as_ref().is_some_and(|p| {
release
.as_ref()
.is_some_and(|r| p.release.version == r.version && p.release.sha256 == r.sha256)
});
if !reusable {
inner.prepared = None;
}
inner.view.available = release;
inner.view.package_ready = reusable;
inner.view.phase = if reusable {
"ready"
} else if inner.view.available.is_some() {
"available"
} else {
"current"
}
.into();
}
Err(error) => state.0.fail(error),
}
state.0.view()
}
#[tauri::command]
pub async fn update_download(
window: WebviewWindow,
state: State<'_, UpdateState>,
) -> Result<UpdateView, String> {
main_window(&window)?;
let release = {
let mut inner = state
.0
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
if !matches!(inner.view.phase.as_str(), "available" | "failed") || inner.prepared.is_some()
{
return Err("UPGRADE_DOWNLOAD_NOT_READY".into());
}
let release = inner
.view
.available
.clone()
.ok_or("UPGRADE_NOT_AVAILABLE")?;
inner.view.phase = "downloading".into();
inner.view.error = None;
inner.view.downloaded_bytes = 0;
state.0.cancelled.store(false, Ordering::SeqCst);
release
};
let result = download::prepare(&state.0, release).await;
match result {
Ok(prepared) => {
let mut inner = state
.0
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
inner.prepared = Some(prepared);
inner.view.phase = "ready".into();
inner.view.package_ready = true;
}
Err(error) if error == "UPGRADE_CANCELLED" => {
state.0.edit(|v| v.phase = "available".into())?
}
Err(error) => state.0.fail(error),
}
state.0.view()
}
#[tauri::command]
pub fn update_cancel(
window: WebviewWindow,
state: State<'_, UpdateState>,
) -> Result<UpdateView, String> {
main_window(&window)?;
let inner = state
.0
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
if !matches!(
inner.view.phase.as_str(),
"downloading" | "verifying" | "waiting"
) {
return Err("UPGRADE_CANCEL_UNAVAILABLE".into());
}
state.0.cancelled.store(true, Ordering::SeqCst);
Ok(inner.view.clone())
}
#[tauri::command]
pub async fn update_install(
window: WebviewWindow,
state: State<'_, UpdateState>,
desktop: State<'_, crate::bridge::DesktopState>,
) -> Result<UpdateView, String> {
main_window(&window)?;
let prepared = {
let mut inner = state
.0
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
if !matches!(inner.view.phase.as_str(), "ready" | "failed") {
return Err("UPGRADE_INSTALL_NOT_READY".into());
}
let prepared = inner.prepared.clone().ok_or("UPGRADE_INSTALL_NOT_READY")?;
inner.view.phase = "waiting".into();
inner.view.error = None;
inner.view.recovery = None;
state.0.cancelled.store(false, Ordering::SeqCst);
prepared
};
let updates = state.0.clone();
let sessions = desktop.0.clone();
let handle = window.app_handle().clone();
tauri::async_runtime::spawn(async move {
if let Err(error) = install(&updates, &sessions, &handle, prepared).await {
let recovery = recover_precommit(&updates, &sessions, &handle).await;
let _ = updates.edit(|view| view.recovery = Some(recovery));
updates.fail(error);
}
});
state.0.view()
}
type Sessions = Arc<tokio::sync::Mutex<Option<crate::session::Session>>>;
async fn resident_call<T: Send + 'static>(
sessions: &Sessions,
call: impl FnOnce(&mut crate::bootstrap::Resident) -> Result<T, String> + Send + 'static,
) -> Result<T, String> {
let session = sessions.clone().lock_owned().await;
tokio::task::spawn_blocking(move || {
call(&mut *crate::bootstrap::resident(
session.as_ref().ok_or("RESIDENT_UNAVAILABLE")?,
)?)
})
.await
.map_err(|_| "UPGRADE_RESIDENT_UNAVAILABLE")?
}
async fn install(
updates: &Updates,
sessions: &Sessions,
app: &tauri::AppHandle,
prepared: PreparedUpdate,
) -> Result<(), String> {
resident_call(sessions, |r| {
if r.upgrade_stop_requested() {
Err("UPGRADE_RESIDENT_STOPPING_RESTART_REQUIRED".into())
} else {
Ok(())
}
})
.await?;
let root = updates
.data_root
.clone()
.ok_or("PRIVATE_PATH_UNAVAILABLE")?;
let copy = prepared.clone();
let handoff = tokio::task::spawn_blocking(move || {
copy.revalidate()?;
installer::prepare(&root, ©)
})
.await
.map_err(|_| "UPGRADE_VERIFY_FAILED")??;
resident_call(sessions, |r| r.upgrade_status(UpgradeAction::Prepare)).await?;
loop {
if updates.cancelled.load(Ordering::SeqCst) {
resident_call(sessions, |r| r.upgrade_status(UpgradeAction::Cancel)).await?;
updates.edit(|v| {
v.phase = "ready".into();
v.active_calls = 0;
v.active_tasks = 0;
})?;
return Ok(());
}
let status = resident_call(sessions, |r| r.upgrade_status(UpgradeAction::Status)).await?;
updates.edit(|v| {
v.active_calls = status.active_calls;
v.active_tasks = status.active_tasks;
})?;
if status.drained() {
let mut inner = updates
.inner
.lock()
.map_err(|_| "UPGRADE_STATE_UNAVAILABLE")?;
if !updates.cancelled.load(Ordering::SeqCst) {
inner.view.phase = "installing".into();
break;
}
}
tokio::time::sleep(std::time::Duration::from_millis(500)).await;
}
let installer = tokio::task::spawn_blocking(move || installer::start(&handoff))
.await
.map_err(|_| "UPGRADE_INSTALLER_UNAVAILABLE")??;
// Preflight succeeded while the old service was alive. An uncommitted helper is
// reaped on every error; it cannot infer authorization from the Desktop disappearing.
resident_call(sessions, |r| r.stop_for_upgrade()).await?;
tokio::task::spawn_blocking(move || installer.commit())
.await
.map_err(|_| "UPGRADE_INSTALLER_COMMIT_FAILED")??;
app.exit(0);
Ok(())
}
async fn recover_precommit(
updates: &Updates,
sessions: &Sessions,
app: &tauri::AppHandle,
) -> UpdateRecovery {
let Some(root) = updates.data_root.clone() else {
return UpdateRecovery::RestartRequired;
};
let Ok(executable) = std::env::current_exe() else {
return UpdateRecovery::RestartRequired;
};
let diagnostics = app.state::<crate::bridge::DiagnosticsState>().startup();
let handle = app.clone();
let mut session = sessions.clone().lock_owned().await;
let result = tokio::task::spawn_blocking(move || {
let current = session.as_mut().ok_or("RESIDENT_UNAVAILABLE")?;
let mut native = crate::bootstrap::resident(current)?;
if !native.upgrade_stop_requested() {
native.upgrade_status(UpgradeAction::Cancel)?;
} else {
crate::bridge::expire_window_confirmations(&handle, "main");
let resident = native.replacement_after_upgrade_stop(
&root,
&executable.with_file_name("hirouted"),
&diagnostics,
)?;
drop(native);
current.invalidate_confirmation();
*session = Some(crate::session_from_resident(resident));
}
Ok::<_, String>(())
})
.await;
match result {
Ok(Ok(())) => {
let client = sessions
.lock()
.await
.as_ref()
.map(|session| session.client.clone());
if let Some(client) = client
&& client
.with_timeout(std::time::Duration::from_secs(2))
.query::<_, hiroute_application_api::SystemStatusV1>(
"GetSystemStatus",
"update-recovery-readiness",
&serde_json::json!({}),
)
.await
.is_ok_and(|response| {
response.error.is_none()
&& response.data.is_some_and(|status| {
status.daemon == "role_all" && status.gateway == "ready"
})
})
{
UpdateRecovery::ServiceAvailable
} else {
UpdateRecovery::RestartRequired
}
}
Ok(Err(code)) if code == "UPGRADE_STOP_PENDING" => UpdateRecovery::StopPending,
_ => UpdateRecovery::RestartRequired,
}
}