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
//! Private login lifecycle. The manifest identifies resources, never grants routing authority.
use std::collections::BTreeMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use parking_lot::Mutex;
use serde::{Deserialize, Serialize};
use crate::config::{SecretText, ensure_private_dir, private_atomic_write, validate_private_file};
use crate::{CpaAccountKind, CpaLifecycleError, ManagedCpaRuntime};
const SCHEMA: &str = "hiroute.cpa-managed-login/v1";
const LOGIN_WINDOW_SECONDS: u64 = 5 * 60;
const MAX_SESSIONS: usize = 32;
#[cfg(test)]
#[path = "managed_sessions/tests.rs"]
mod tests;
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum CpaLoginState {
Pending,
Authorized,
Cancelled,
Failed,
Expired,
Forgotten,
}
#[derive(Clone, Debug)]
pub struct CpaLoginSession {
pub login_ref: String,
pub kind: CpaAccountKind,
pub state: CpaLoginState,
pub account_ref: Option<String>,
pub manual_callback_required: bool,
}
impl CpaLoginSession {
pub fn candidate_ref(&self) -> String {
format!(
"candidate/cpa/{}/managed/{}",
self.kind.stock_provider(),
self.login_ref
)
}
}
#[derive(Clone, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct LoginRecord {
schema: String,
login_ref: String,
kind: CpaAccountKind,
state: CpaLoginState,
created_at: u64,
expires_at: u64,
oauth_state: Option<String>,
account_ref: Option<String>,
}
impl LoginRecord {
fn safe(&self) -> CpaLoginSession {
CpaLoginSession {
login_ref: self.login_ref.clone(),
kind: self.kind,
state: self.state,
account_ref: self.account_ref.clone(),
manual_callback_required: false,
}
}
}
struct Session {
record: LoginRecord,
runtime: Arc<ManagedCpaRuntime>,
manual_callback_required: bool,
}
impl Session {
fn safe(&self) -> CpaLoginSession {
let mut safe = self.record.safe();
safe.manual_callback_required =
safe.state == CpaLoginState::Pending && self.manual_callback_required;
safe
}
}
pub(crate) struct ManagedLoginRegistry {
root: PathBuf,
sessions: Mutex<BTreeMap<String, Session>>,
}
impl ManagedLoginRegistry {
pub(crate) fn load(
root: PathBuf,
templates: &[Arc<ManagedCpaRuntime>],
) -> Result<Self, CpaLifecycleError> {
let registry = Self {
root,
sessions: Mutex::new(BTreeMap::new()),
};
if !registry.root.exists() {
return Ok(registry);
}
private_session_dir(®istry.root)?;
let mut sessions = registry.sessions.lock();
#[cfg(windows)]
let entries = crate::windows_private::names(®istry.root)
.map_err(|_| CpaLifecycleError::OwnerState)?;
#[cfg(not(windows))]
let entries = std::fs::read_dir(®istry.root)
.map_err(|_| CpaLifecycleError::OwnerState)?
.map(|entry| entry.map(|entry| entry.file_name().to_string_lossy().into_owned()))
.collect::<Result<Vec<_>, _>>()
.map_err(|_| CpaLifecycleError::OwnerState)?;
for id in entries {
if !valid_login_ref(&id) || sessions.len() >= MAX_SESSIONS {
continue;
}
// Preserve damaged or unavailable resources in place. A broken optional login
// cannot hide an independently valid sibling, and absent sessions cannot route.
if let Ok(Some(session)) = registry.restore_session(templates, &id) {
sessions.insert(id, session);
}
}
drop(sessions);
Ok(registry)
}
fn restore_session(
&self,
templates: &[Arc<ManagedCpaRuntime>],
id: &str,
) -> Result<Option<Session>, CpaLifecycleError> {
private_session_dir(&self.session_dir(id))?;
let path = self.session_dir(id).join("login.json");
if !path.exists() {
return Ok(None);
}
validate_private_file(&path)?;
#[cfg(windows)]
let bytes = crate::windows_private::read(&path, 16384)
.map_err(|_| CpaLifecycleError::OwnerState)?;
#[cfg(not(windows))]
let bytes = {
if std::fs::metadata(&path)
.map_err(|_| CpaLifecycleError::OwnerState)?
.len()
> 16384
{
return Err(CpaLifecycleError::OwnerState);
}
std::fs::read(&path).map_err(|_| CpaLifecycleError::OwnerState)?
};
let record: LoginRecord =
serde_json::from_slice(&bytes).map_err(|_| CpaLifecycleError::OwnerState)?;
if record.schema != SCHEMA
|| record.login_ref != id
|| record.expires_at < record.created_at
|| record
.oauth_state
.as_ref()
.is_some_and(|s| s.is_empty() || s.len() > 4096)
|| (record.state == CpaLoginState::Authorized
&& record.account_ref.as_ref().is_none_or(|a| {
!a.strip_prefix("account/cpa/")
.is_some_and(|d| d.len() == 64 && d.bytes().all(|b| b.is_ascii_hexdigit()))
}))
{
return Err(CpaLifecycleError::OwnerState);
}
let runtime = self.make_runtime(templates, &record)?;
let mut session = Session {
record,
runtime,
manual_callback_required: false,
};
if session.record.state == CpaLoginState::Pending {
// Stop only an authenticated existing owner. Recovery cannot start a new
// refresh writer before saved management has granted execution.
session.runtime.stop_existing_managed_process()?;
clear_auth(&self.session_dir(id).join("auth"))?;
session.record.state = CpaLoginState::Expired;
session.record.oauth_state = None;
self.save(&session.record)?;
} else if matches!(
session.record.state,
CpaLoginState::Authorized | CpaLoginState::Failed
) {
// Saved management chooses which refresh process may subsequently run.
session.runtime.stop_existing_managed_process()?;
}
Ok(Some(session))
}
pub(crate) fn start(
&self,
templates: &[Arc<ManagedCpaRuntime>],
kind: CpaAccountKind,
) -> Result<(CpaLoginSession, String), CpaLifecycleError> {
let mut sessions = self.sessions.lock();
for session in sessions
.values_mut()
.filter(|s| s.record.kind == kind && s.record.state == CpaLoginState::Pending)
{
if now()? >= session.record.expires_at {
self.stop_session(session, CpaLoginState::Expired)?;
}
}
if sessions.len() >= MAX_SESSIONS {
let removable = sessions
.values()
.filter(|s| {
matches!(
s.record.state,
CpaLoginState::Cancelled
| CpaLoginState::Expired
| CpaLoginState::Forgotten
)
})
.min_by_key(|s| s.record.created_at)
.map(|s| s.record.login_ref.clone());
if let Some(id) = removable {
let path = self.session_dir(&id);
private_session_dir(&path)?;
#[cfg(windows)]
crate::windows_private::remove_session_tree(&path, false)
.map_err(|_| CpaLifecycleError::OwnerState)?;
#[cfg(not(windows))]
std::fs::remove_dir_all(path).map_err(|_| CpaLifecycleError::OwnerState)?;
sessions.remove(&id);
}
}
if sessions.len() >= MAX_SESSIONS
|| sessions
.values()
.any(|s| s.record.kind == kind && s.record.state == CpaLoginState::Pending)
{
return Err(CpaLifecycleError::AlreadyOwned);
}
private_session_dir(&self.root)?;
let id = format!("login-{}", SecretText::generate()?.expose());
let now = now()?;
let mut record = LoginRecord {
schema: SCHEMA.into(),
login_ref: id.clone(),
kind,
state: CpaLoginState::Pending,
created_at: now,
expires_at: now + LOGIN_WINDOW_SECONDS,
oauth_state: None,
account_ref: None,
};
private_session_dir(&self.session_dir(&id))?;
self.save(&record)?;
let runtime = self.make_runtime(templates, &record)?;
// A logged-in but unchecked credential is never an execution grant.
runtime.suspend_subscription_execution();
let login = match runtime.oauth_start() {
Ok(login) => login,
Err(error) => {
let _ = runtime.shutdown();
record.state = CpaLoginState::Failed;
self.save(&record)?;
sessions.insert(
id,
Session {
record,
runtime,
manual_callback_required: false,
},
);
return Err(error);
}
};
record.oauth_state = Some(login.state);
self.save(&record)?;
let session = Session {
record,
runtime,
manual_callback_required: login.manual_callback_required,
};
let safe = session.safe();
sessions.insert(id, session);
Ok((safe, login.authorization_url))
}
pub(crate) fn list(&self, kind: CpaAccountKind) -> Vec<CpaLoginSession> {
self.sessions
.lock()
.values()
.filter(|s| s.record.kind == kind)
.map(|s| s.safe())
.collect()
}
pub(crate) fn status(&self, id: &str) -> Result<CpaLoginSession, CpaLifecycleError> {
let mut sessions = self.sessions.lock();
let session = sessions
.get_mut(id)
.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
if session.record.state != CpaLoginState::Pending {
return Ok(session.safe());
}
if now()? >= session.record.expires_at {
self.stop_session(session, CpaLoginState::Expired)?;
return Ok(session.safe());
}
let oauth_state = session
.record
.oauth_state
.as_deref()
.ok_or(CpaLifecycleError::OwnerState)?;
match session.runtime.oauth_status(oauth_state)? {
crate::CpaOAuthStatus::Pending => {}
crate::CpaOAuthStatus::Complete => {
let credentials = session.runtime.managed_credentials()?;
if credentials.len() != 1 || credentials[0].kind != session.record.kind {
self.stop_session(session, CpaLoginState::Failed)?;
} else {
// Unsaved authorizations do not need a background refresh process.
// Keep Pending on a stop failure so maintenance retries cleanup.
session.runtime.stop_existing_managed_process()?;
let mut authorized = session.record.clone();
authorized.account_ref = Some(credentials[0].account_ref.clone());
authorized.state = CpaLoginState::Authorized;
authorized.oauth_state = None;
self.save(&authorized)?;
session.record = authorized;
}
}
crate::CpaOAuthStatus::Failed => self.stop_session(session, CpaLoginState::Failed)?,
}
Ok(session.safe())
}
/// Daemon-owned housekeeping continues even when the login client has disconnected.
/// A failed optional session must not prevent another provider from completing cleanup.
pub(crate) fn maintain(&self) -> Result<(), CpaLifecycleError> {
let pending = self
.sessions
.lock()
.values()
.filter(|session| session.record.state == CpaLoginState::Pending)
.map(|session| session.record.login_ref.clone())
.collect::<Vec<_>>();
let mut first_error = None;
for id in pending {
if let Err(error) = self.status(&id) {
first_error.get_or_insert(error);
}
}
first_error.map_or(Ok(()), Err)
}
pub(crate) fn callback(&self, id: &str, value: &str) -> Result<(), CpaLifecycleError> {
let sessions = self.sessions.lock();
let session = sessions
.get(id)
.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
if session.record.state != CpaLoginState::Pending || now()? >= session.record.expires_at {
return Err(CpaLifecycleError::StaleSourceManagement);
}
let state = session
.record
.oauth_state
.as_deref()
.ok_or(CpaLifecycleError::OwnerState)?;
session.runtime.oauth_submit_callback(state, value)
}
pub(crate) fn cancel(
&self,
id: &str,
forget: bool,
) -> Result<CpaLoginSession, CpaLifecycleError> {
let mut sessions = self.sessions.lock();
let session = sessions
.get_mut(id)
.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
if !forget && session.record.state == CpaLoginState::Authorized {
return Err(CpaLifecycleError::InvalidSourceManagement);
}
self.stop_session(
session,
if forget {
CpaLoginState::Forgotten
} else {
CpaLoginState::Cancelled
},
)?;
Ok(session.safe())
}
pub(crate) fn for_candidate(&self, candidate: &str) -> Option<Arc<ManagedCpaRuntime>> {
let sessions = crate::request_context::lock(&self.sessions).ok()?;
sessions
.values()
.find(|session| {
session.record.state == CpaLoginState::Authorized
&& session.safe().candidate_ref() == candidate
})
.map(|session| session.runtime.clone())
}
pub(crate) fn session(&self, id: &str) -> Option<CpaLoginSession> {
self.sessions.lock().get(id).map(|s| s.safe())
}
pub(crate) fn all_runtimes(&self) -> Vec<Arc<ManagedCpaRuntime>> {
self.sessions
.lock()
.values()
.map(|s| s.runtime.clone())
.collect()
}
fn stop_session(
&self,
session: &mut Session,
terminal: CpaLoginState,
) -> Result<(), CpaLifecycleError> {
session.runtime.suspend_subscription_execution();
// Reconstructed runtimes may have a live orphan, but stopping or forgetting an
// inactive login must never spawn a process or rotate its refresh token.
// Stopping the process also cancels CPA's in-memory OAuth session and tasks.
session.runtime.stop_existing_managed_process()?;
// Commit the terminal state only after deletion. An interrupted cleanup remains
// retryable through the original session and cannot leave a false success receipt.
clear_auth(&self.session_dir(&session.record.login_ref).join("auth"))?;
session.record.state = terminal;
session.record.oauth_state = None;
session.record.account_ref = None;
self.save(&session.record)
}
fn make_runtime(
&self,
templates: &[Arc<ManagedCpaRuntime>],
record: &LoginRecord,
) -> Result<Arc<ManagedCpaRuntime>, CpaLifecycleError> {
let template = templates
.iter()
.find(|runtime| runtime.managed_kind() == Some(record.kind))
.ok_or(CpaLifecycleError::InvalidSpec)?;
let runtime = template.fork_managed_oauth(
record.login_ref.clone(),
self.session_dir(&record.login_ref).join("auth"),
record.kind,
)?;
runtime.suspend_subscription_execution();
Ok(Arc::new(runtime))
}
fn session_dir(&self, id: &str) -> PathBuf {
self.root.join(id)
}
fn save(&self, record: &LoginRecord) -> Result<(), CpaLifecycleError> {
let bytes = serde_json::to_vec(record).map_err(|_| CpaLifecycleError::OwnerState)?;
private_atomic_write(
&self.session_dir(&record.login_ref).join("login.json"),
&bytes,
)?;
Ok(())
}
}
fn valid_login_ref(value: &str) -> bool {
value.strip_prefix("login-").is_some_and(|id| {
id.len() == 43
&& id
.bytes()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_'))
})
}
fn now() -> Result<u64, CpaLifecycleError> {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|value| value.as_secs())
.map_err(|_| CpaLifecycleError::OwnerState)
}
fn clear_auth(path: &Path) -> Result<(), CpaLifecycleError> {
if !path.exists() {
return Ok(());
}
private_session_dir(path)?;
// Stop was confirmed before this exact owner-only directory is removed. Never follow links.
#[cfg(windows)]
{
crate::windows_private::remove_session_tree(path, true)
.map_err(|_| CpaLifecycleError::OwnerState)
}
#[cfg(not(windows))]
{
std::fs::remove_dir_all(path).map_err(|_| CpaLifecycleError::OwnerState)
}
}
fn private_session_dir(path: &Path) -> Result<(), CpaLifecycleError> {
if let Ok(metadata) = std::fs::symlink_metadata(path)
&& (!metadata.is_dir() || metadata.file_type().is_symlink())
{
return Err(CpaLifecycleError::OwnerState);
}
ensure_private_dir(path)?;
Ok(())
}