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
//! Remove only manifest-owned versioned payloads, retaining recovery sources until commit.
use super::*;
use serde::Serialize;
use std::{collections::BTreeSet, fs, path::PathBuf};
#[derive(Default, Serialize)]
pub struct PackageCleanup {
pub removed: Vec<PathBuf>,
pub preserved: Vec<PathBuf>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
}
impl PackageCleanup {
#[cfg(any(windows, test))]
pub(crate) fn best_effort(result: io::Result<Self>) -> Self {
result.unwrap_or_else(|error| Self {
error: Some(error.to_string()),
..Self::default()
})
}
}
pub fn prune_packages(
base: &Path,
target: &str,
retained: &[PathBuf],
) -> io::Result<PackageCleanup> {
windows_machine(target)?;
let mut report = PackageCleanup::default();
// The regular-file helper also admits every ancestor without following links.
regular(&base.join("package-manifest.json"))?;
let entries = match fs::read_dir(base) {
Ok(entries) => entries,
Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(report),
Err(error) => return Err(error),
};
for entry in entries {
let root = entry?.path();
if retained.contains(&root) {
continue;
}
match remove_package(&root, target) {
Ok(()) => report.removed.push(root),
// Modified, foreign, busy or unrecognised material remains available for repair.
Err(_) => report.preserved.push(root),
}
}
Ok(report)
}
fn inventory(root: &Path, expected: &BTreeSet<PathBuf>) -> io::Result<()> {
regular(&root.join("package-manifest.json"))?;
for entry in fs::read_dir(root)? {
let path = entry?.path();
if !expected.contains(&path) {
return Err(invalid());
}
let metadata = fs::symlink_metadata(&path)?;
if metadata.is_dir() {
inventory(&path, expected)?;
} else {
regular(&path)?.ok_or_else(invalid)?;
}
}
Ok(())
}
fn remove_package(root: &Path, target: &str) -> io::Result<()> {
let manifest = root.join("package-manifest.json");
let package: Package = read_json(&manifest, 1024 * 1024)?.ok_or_else(invalid)?;
package.validate()?;
if root.file_name() != Some(std::ffi::OsStr::new(&package.directory_name()))
|| package.target != target
{
return Err(invalid());
}
#[cfg(windows)]
if let Some(cli) = regular(&root.join("hiroute.exe"))? {
let running =
hiroute_platform::windows::security::open_identity(&std::env::current_exe()?, false)?;
if hiroute_platform::windows::security::file_identity(&cli)?
== hiroute_platform::windows::security::file_identity(&running)?
{
return Err(io::Error::other("INSTALL_PACKAGE_IN_USE"));
}
}
let mut directories = BTreeSet::new();
let mut expected = BTreeSet::from([manifest.clone()]);
let mut files = vec![];
for (name, facts) in &package.files {
let path = root.join(Package::relative(name));
expected.insert(path.clone());
let mut parent = path.parent().ok_or_else(invalid)?;
while parent != root {
directories.insert(parent.to_owned());
expected.insert(parent.to_owned());
parent = parent.parent().ok_or_else(invalid)?;
}
if let Some(file) = regular(&path)? {
if file.metadata()?.len() != facts.size
|| digest(&path)?.as_ref() != Some(&facts.sha256)
{
return Err(invalid());
}
files.push((path, facts.sha256.clone()));
}
}
// Admit the entire remaining inventory before the first deletion. Missing owned
// entries are allowed so a power loss during committed cleanup is resumable.
inventory(root, &expected)?;
let manifest_digest = digest(&manifest)?.ok_or_else(invalid)?;
for (path, expected) in files {
if digest(&path)?.as_ref() != Some(&expected) {
return Err(invalid());
}
remove_owned(&path)?;
}
let mut directories: Vec<_> = directories.into_iter().collect();
directories.sort_by_key(|path| std::cmp::Reverse(path.components().count()));
for path in directories {
match fs::remove_dir(&path) {
Ok(()) => {}
Err(error) if error.kind() == io::ErrorKind::NotFound => {}
Err(error) => return Err(error),
}
}
if digest(&manifest)?.as_ref() != Some(&manifest_digest) {
return Err(invalid());
}
remove_owned(&manifest)?;
fs::remove_dir(root)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn inaccessible_package_base_reports_cleanup_without_failing_the_committed_operation() {
let temp = tempfile::tempdir().unwrap();
let base = temp.path().join("not-a-directory");
fs::write(&base, b"preserve unknown material").unwrap();
let report =
PackageCleanup::best_effort(prune_packages(&base, "x86_64-pc-windows-msvc", &[]));
assert!(report.error.is_some());
assert!(report.removed.is_empty());
assert_eq!(fs::read(base).unwrap(), b"preserve unknown material");
}
fn fixture() -> (tempfile::TempDir, PathBuf, PathBuf) {
let temp = tempfile::tempdir().unwrap();
let base = temp.path().canonicalize().unwrap().join("packages");
fs::create_dir(&base).unwrap();
let (source, package) =
super::super::package::tests::fixture("x86_64-pc-windows-msvc", 0x8664);
let root = base.join(package.directory_name());
fs::rename(source.path(), &root).unwrap();
(temp, base, root)
}
#[test]
fn current_and_shell_rollback_sources_survive_until_their_owners_commit() {
let (_temp, base, root) = fixture();
let report =
prune_packages(&base, "x86_64-pc-windows-msvc", std::slice::from_ref(&root)).unwrap();
assert!(report.removed.is_empty());
assert!(root.join("hirouted.exe").exists());
let report = prune_packages(&base, "x86_64-pc-windows-msvc", &[]).unwrap();
assert_eq!(report.removed.as_slice(), std::slice::from_ref(&root));
assert!(!root.exists());
assert!(
prune_packages(&base, "x86_64-pc-windows-msvc", &[])
.unwrap()
.removed
.is_empty()
);
}
#[test]
fn interrupted_cleanup_resumes_using_the_retained_manifest() {
let (_temp, base, root) = fixture();
fs::remove_file(root.join("hiroute.exe")).unwrap();
assert_eq!(
prune_packages(&base, "x86_64-pc-windows-msvc", &[])
.unwrap()
.removed
.as_slice(),
std::slice::from_ref(&root)
);
assert!(!root.exists());
}
#[test]
fn changed_files_foreign_entries_and_other_targets_are_preserved_before_any_deletion() {
for kind in ["changed", "foreign", "directory", "target"] {
let (_temp, base, root) = fixture();
let target = if kind == "target" {
"aarch64-pc-windows-msvc"
} else {
"x86_64-pc-windows-msvc"
};
match kind {
"changed" => fs::write(root.join("hirouted.exe"), b"changed").unwrap(),
"foreign" => fs::write(root.join("my-file"), b"foreign").unwrap(),
"directory" => fs::create_dir(root.join("my-directory")).unwrap(),
_ => {}
}
let report = prune_packages(&base, target, &[]).unwrap();
assert_eq!(report.preserved.as_slice(), std::slice::from_ref(&root));
assert!(root.join("hiroute.exe").exists());
assert!(root.join("package-manifest.json").exists());
}
}
#[cfg(unix)]
#[test]
fn linked_payload_roots_never_redirect_cleanup() {
use std::os::unix::fs::symlink;
let (_temp, base, root) = fixture();
let original = root.with_extension("foreign");
fs::rename(&root, &original).unwrap();
symlink(&original, &root).unwrap();
let report = prune_packages(&base, "x86_64-pc-windows-msvc", &[]).unwrap();
assert_eq!(report.preserved.len(), 2);
assert!(original.join("hiroute.exe").exists());
}
}