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 super::*;
fn private_home() -> tempfile::TempDir {
let builder = tempfile::Builder::new();
#[cfg(unix)]
let builder = {
let mut builder = builder;
use std::os::unix::fs::PermissionsExt;
builder.permissions(fs::Permissions::from_mode(0o700));
builder
};
builder.tempdir().unwrap()
}
#[cfg(windows)]
#[test]
fn windows_proxy_handoff_preserves_one_logical_key_and_rejects_ambiguous_values() {
let equal = snapshot(&[
("HTTP_PROXY", "http://proxy:9"),
("http_proxy", "http://proxy:9"),
]);
assert_eq!(equal.variables().count(), 1);
assert_eq!(equal.variables().next().unwrap().0, "HTTP_PROXY");
assert!(
ServiceProxyEnvironment::capture([
("HTTP_PROXY".into(), "http://first:9".into()),
("http_proxy".into(), "http://other:9".into()),
])
.is_err()
);
}
fn snapshot(values: &[(&str, &str)]) -> ServiceProxyEnvironment {
ServiceProxyEnvironment::capture(values.iter().map(|(k, v)| (k.into(), v.into()))).unwrap()
}
#[test]
fn handoff_is_private_bounded_redacted_and_replaces_the_whole_environment() {
let home = private_home();
assert!(
ServiceProxyEnvironment::load(home.path())
.unwrap()
.is_none()
);
let value = snapshot(&[
(
"https_proxy",
"http://user:[email protected]:1187",
),
("NO_PROXY", "localhost,.example.test"),
("OPENAI_API_KEY", "must-not-forward"),
("BASH_ENV", "must-not-execute"),
]);
value.store(home.path()).unwrap();
let loaded = ServiceProxyEnvironment::load(home.path()).unwrap().unwrap();
assert_eq!(loaded.variables, value.variables);
assert_eq!(loaded.variables.len(), 2);
assert!(!format!("{loaded:?}").contains("private-proxy-password"));
let path = ServiceProxyEnvironment::path(home.path());
let bytes = fs::read(&path).unwrap();
assert!(!String::from_utf8(bytes).unwrap().contains("must-not"));
#[cfg(windows)]
hiroute_platform::windows::security::verify_owner_only(&path, false).unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
assert_eq!(
fs::metadata(&path).unwrap().permissions().mode() & 0o777,
0o600
);
}
snapshot(&[]).store(home.path()).unwrap();
assert!(
ServiceProxyEnvironment::load(home.path())
.unwrap()
.unwrap()
.variables
.is_empty()
);
}
#[test]
fn unknown_malformed_and_oversized_snapshots_fail_without_exposing_values() {
let home = private_home();
snapshot(&[]).store(home.path()).unwrap();
let path = ServiceProxyEnvironment::path(home.path());
for data in [
format!(r#"{{"schema":"{SCHEMA}","variables":{{"LD_PRELOAD":"secret"}}}}"#),
format!(r#"{{"schema":"{SCHEMA}","variables":{{}},"extra":"secret"}}"#),
"secret invalid JSON".into(),
"x".repeat(MAX_BYTES as usize + 1),
] {
fs::write(&path, data).unwrap();
let error = ServiceProxyEnvironment::load(home.path()).unwrap_err();
assert!(!error.to_string().contains("secret"));
}
for value in [
"http://proxy\nLD_PRELOAD=bad".to_owned(),
"x".repeat(MAX_BYTES as usize),
] {
assert!(ServiceProxyEnvironment::capture([("HTTPS_PROXY".into(), value.into())]).is_err());
}
}
#[cfg(unix)]
#[test]
fn accepts_accessible_modes_but_refuses_symlink_parents_and_files() {
use std::os::unix::fs::{PermissionsExt, symlink};
let home = private_home();
let other = private_home();
symlink(other.path(), home.path().join(".local")).unwrap();
assert!(snapshot(&[]).store(home.path()).is_err());
assert!(ServiceProxyEnvironment::load(home.path()).is_err());
fs::remove_file(home.path().join(".local")).unwrap();
snapshot(&[]).store(home.path()).unwrap();
let path = ServiceProxyEnvironment::path(home.path());
fs::set_permissions(&path, fs::Permissions::from_mode(0o644)).unwrap();
assert!(
ServiceProxyEnvironment::load(home.path())
.unwrap()
.is_some()
);
assert_eq!(
fs::metadata(&path).unwrap().permissions().mode() & 0o777,
0o644
);
snapshot(&[]).store(home.path()).unwrap();
fs::remove_file(&path).unwrap();
let target = other.path().join("untouched");
symlink(&target, &path).unwrap();
assert!(ServiceProxyEnvironment::load(home.path()).is_err());
assert!(snapshot(&[]).store(home.path()).is_err());
assert!(!target.exists());
}