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 auth() -> (tempfile::TempDir, ConsoleAuth) {
let root = tempfile::tempdir().unwrap();
let auth = ConsoleAuth::open(root.path()).unwrap();
(root, auth)
}
fn local_target() -> LaunchTarget {
LaunchTarget::new("127.0.0.1:5838".parse().unwrap(), true)
}
fn peer() -> IpAddr {
"127.0.0.1".parse().unwrap()
}
fn headers(bearer: &str) -> HeaderMap {
let mut h = HeaderMap::new();
h.insert(
http::header::AUTHORIZATION,
format!("Bearer {bearer}").parse().unwrap(),
);
h
}
#[test]
fn launch_is_loopback_only_short_lived_and_single_use() {
let (_root, mut a) = auth();
let code = a.create_launch(local_target()).unwrap();
assert!(matches!(
a.exchange_launch(&code, "192.0.2.1".parse().unwrap(), &local_target().origin),
Err(AuthError::Invalid)
));
let session = a
.exchange_launch(&code, peer(), &local_target().origin)
.unwrap();
assert!(a.authenticate(&headers(&session.bearer), peer()).is_ok());
assert!(
a.exchange_launch(&code, peer(), &local_target().origin)
.is_err()
);
let code = a.create_launch(local_target()).unwrap();
a.launches.get_mut(&hash(&code)).unwrap().expires = now().unwrap() - 1;
assert!(
a.exchange_launch(&code, peer(), &local_target().origin)
.is_err()
);
}
#[test]
fn token_revocation_ends_sessions_and_disk_never_contains_credentials() {
let (root, mut a) = auth();
let token = a.create_token("Test".into(), None).unwrap();
let session = a.exchange_token(&token.token, peer()).unwrap();
a.audit_command(
&session.session,
"1234567890abcdef",
"observation_read",
Some("operation-one"),
)
.unwrap();
a.revoke_token(&token.metadata.id).unwrap();
assert!(a.authenticate(&headers(&session.bearer), peer()).is_err());
for entry in std::fs::read_dir(root.path().join("console")).unwrap() {
let bytes = std::fs::read_to_string(entry.unwrap().path()).unwrap();
assert!(!bytes.contains(&token.token));
assert!(!bytes.contains(&session.bearer));
}
let mut reopened = ConsoleAuth::open(root.path()).unwrap();
assert!(reopened.exchange_token(&token.token, peer()).is_err());
}
#[test]
fn idle_absolute_and_credential_expiry_end_authority() {
let (_root, mut a) = auth();
for absolute in [false, true] {
let code = a.create_launch(local_target()).unwrap();
let session = a
.exchange_launch(&code, peer(), &local_target().origin)
.unwrap();
let entry = a.sessions.get_mut(&hash(&session.bearer)).unwrap();
if absolute {
entry.created = now().unwrap() - ABSOLUTE_TTL;
} else {
entry.last_used = now().unwrap() - IDLE_TTL;
}
assert!(a.authenticate(&headers(&session.bearer), peer()).is_err());
}
let token = a.create_token("Expired".into(), Some(1)).unwrap();
a.tokens[0].metadata.expires = Some(now().unwrap() - 1);
assert!(a.exchange_token(&token.token, peer()).is_err());
}
#[test]
fn failed_exchanges_have_per_peer_and_global_bounded_limits() {
let (_root, mut a) = auth();
for _ in 0..8 {
assert_eq!(
a.exchange_token("invalid", peer()).err(),
Some(AuthError::Invalid)
);
}
assert_eq!(
a.exchange_token("invalid", peer()).err(),
Some(AuthError::RateLimited)
);
for i in 0..64 {
let ip = IpAddr::V4(std::net::Ipv4Addr::new(192, 0, 2, i + 1));
assert_eq!(
a.exchange_token("invalid", ip).err(),
Some(AuthError::Invalid)
);
}
assert_eq!(
a.exchange_token("invalid", "198.51.100.1".parse().unwrap())
.err(),
Some(AuthError::RateLimited)
);
assert_eq!(a.failures.len(), 72);
let code = a.create_launch(local_target()).unwrap();
let local = "127.0.0.2".parse().unwrap();
let session = a
.exchange_launch(&code, local, &local_target().origin)
.unwrap();
assert!(a.authenticate(&headers(&session.bearer), local).is_ok());
// A separate local peer limit still applies; isolation is not an exemption.
assert_eq!(
a.exchange_launch(&code, peer(), &local_target().origin)
.err(),
Some(AuthError::RateLimited)
);
}
#[test]
fn bearer_is_explicit_and_capacity_evicts_the_least_recently_used_session() {
let (root, mut a) = auth();
assert!(a.authenticate(&HeaderMap::new(), peer()).is_err());
let mut sessions = vec![];
for _ in 0..16 {
let code = a.create_launch(local_target()).unwrap();
sessions.push(
a.exchange_launch(&code, peer(), &local_target().origin)
.unwrap(),
);
}
// Refresh the oldest session: the second session must now be evicted.
assert!(
a.authenticate(&headers(&sessions[0].bearer), peer())
.is_ok()
);
let code = a.create_launch(local_target()).unwrap();
let newest = a
.exchange_launch(&code, peer(), &local_target().origin)
.unwrap();
assert_eq!(a.sessions.len(), 16);
assert!(
a.authenticate(&headers(&sessions[0].bearer), peer())
.is_ok()
);
assert!(
a.authenticate(&headers(&sessions[1].bearer), peer())
.is_err()
);
assert!(a.authenticate(&headers(&newest.bearer), peer()).is_ok());
assert!(!a.session_active(&sessions[1].session.id));
assert!(
std::fs::read_to_string(root.path().join("console/audit.jsonl"))
.unwrap()
.contains("session_evicted")
);
let b = ConsoleAuth::open(root.path()).unwrap();
assert!(b.sessions.is_empty());
}
#[test]
fn invalid_credentials_cannot_evict_sessions_and_local_failures_do_not_block_remote_login() {
let (_root, mut a) = auth();
let token = a.create_token("Remote".into(), None).unwrap();
for _ in 0..16 {
a.exchange_token(&token.token, peer()).unwrap();
}
let before: Vec<_> = a.sessions.keys().cloned().collect();
assert_eq!(
a.exchange_token("invalid", peer()).err(),
Some(AuthError::Invalid)
);
assert_eq!(a.sessions.keys().cloned().collect::<Vec<_>>(), before);
for i in 1..=63 {
let ip = IpAddr::V4(std::net::Ipv4Addr::new(127, 0, 0, i + 1));
assert_eq!(
a.exchange_token("invalid", ip).err(),
Some(AuthError::Invalid)
);
}
assert_eq!(
a.exchange_token("invalid", "127.0.1.1".parse().unwrap())
.err(),
Some(AuthError::RateLimited)
);
assert!(
a.exchange_token(&token.token, "192.0.2.1".parse().unwrap())
.is_ok()
);
// The failure window expires without restarting the service.
let old = now().unwrap() - 61;
for (at, _) in &mut a.failures {
*at = old;
}
assert!(a.exchange_token(&token.token, peer()).is_ok());
}
#[cfg(unix)]
#[test]
fn foreign_modes_links_and_corrupt_store_are_preserved_and_refused() {
use std::os::unix::fs::{PermissionsExt, symlink};
let (root, mut a) = auth();
a.create_token("One".into(), None).unwrap();
let path = root.path().join("console/tokens.json");
let bytes = std::fs::read(&path).unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
assert!(ConsoleAuth::open(root.path()).is_err());
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
std::fs::remove_file(&path).unwrap();
let foreign = root.path().join("foreign");
std::fs::write(&foreign, &bytes).unwrap();
symlink(&foreign, &path).unwrap();
assert!(ConsoleAuth::open(root.path()).is_err());
assert_eq!(std::fs::read(&foreign).unwrap(), bytes);
}
#[test]
fn network_launch_is_origin_port_bound_and_mismatches_do_not_consume_it() {
let (root, mut auth) = auth();
let remote: IpAddr = "198.51.100.20".parse().unwrap();
for address in ["192.0.2.1:5838", "[2001:db8::1]:80"] {
let target = LaunchTarget::new(address.parse().unwrap(), false);
let code = auth.create_launch(target.clone()).unwrap();
for wrong in [
"http://192.0.2.1:5839",
"http://127.0.0.1:5838",
"http://evil.example:5838",
] {
assert_eq!(
auth.exchange_launch(&code, remote, wrong).err(),
Some(AuthError::Invalid)
);
}
let session = auth.exchange_launch(&code, remote, &target.origin).unwrap();
assert!(auth.authenticate(&headers(&session.bearer), remote).is_ok());
assert_eq!(
auth.exchange_launch(&code, remote, &target.origin).err(),
Some(AuthError::Invalid)
);
let audit = std::fs::read_to_string(root.path().join("console/audit.jsonl")).unwrap();
assert!(!audit.contains(code.as_str()));
assert!(!audit.contains(&session.bearer));
}
}