Skip to content

Switchyard lets LLM applications route traffic across models and providers while preserving native OpenAI and Anthropic API compatibility - enabling flexible model selection, benchmarking, and cost/performance optimization.

Rust
8.3 KB
Raw Blame
// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

//! Named login directories use the harness's own authentication commands.

use crate::harness::{self, Harness};
use std::path::{Path, PathBuf};

// PendingAccount removes only an empty directory if login setup fails.
// The harness may already have saved login files, which must stay.
struct PendingAccount(Option<PathBuf>);

impl Drop for PendingAccount {
    fn drop(&mut self) {
        if let Some(path) = &self.0 {
            let _ = std::fs::remove_dir(path);
        }
    }
}

fn root(tool: Harness) -> Result<PathBuf, String> {
    let name = match tool {
        Harness::CodexCli => "codex",
        Harness::Claude => "claude",
        _ => return Err("Named accounts are available for Codex CLI and Claude Code.".into()),
    };
    let home = crate::config::expand_home(Path::new("~"))?;
    let mut path = home;
    for component in [".switchyard", "accounts", name] {
        path.push(component);
        if std::fs::symlink_metadata(&path).is_ok_and(|m| m.file_type().is_symlink()) {
            return Err(format!(
                "{} is a symlink. Edit its target yourself.",
                path.display()
            ));
        }
    }
    Ok(path)
}

pub fn validate(tool: Harness, path: &Path) -> Result<(), String> {
    let root = root(tool)?;
    if path.parent() != Some(root.as_path())
        || !std::fs::symlink_metadata(path).is_ok_and(|m| m.is_dir() && !m.file_type().is_symlink())
    {
        return Err(format!(
            "{} is not a saved account folder. Choose an account folder that exists and is not a symlink.",
            path.display()
        ));
    }
    Ok(())
}

pub fn discover(tool: Harness) -> Result<Vec<(String, PathBuf)>, String> {
    if !matches!(tool, Harness::CodexCli | Harness::Claude) {
        return Ok(Vec::new());
    }
    let root = root(tool)?;
    let entries = match std::fs::read_dir(&root) {
        Ok(entries) => entries,
        Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(Vec::new()),
        Err(error) => {
            return Err(format!(
                "Could not list accounts in {}: {error}",
                root.display()
            ));
        }
    };
    let mut accounts = Vec::new();
    for entry in entries {
        let entry = entry.map_err(|error| error.to_string())?;
        if !entry
            .file_name()
            .to_string_lossy()
            .starts_with(".archived-")
            && entry
                .file_type()
                .map_err(|error| error.to_string())?
                .is_dir()
            && let Ok(name) = entry.file_name().into_string()
        {
            accounts.push((name, entry.path()));
        }
    }
    accounts.sort_by(|a, b| a.0.cmp(&b.0));
    Ok(accounts)
}

pub fn list(tool: Harness) -> Vec<(String, PathBuf)> {
    discover(tool).unwrap_or_default()
}

pub fn config_paths(tool: Harness, account: Option<&Path>) -> Result<Vec<PathBuf>, String> {
    let Some(account) = account else {
        return harness::paths(tool);
    };
    match tool {
        Harness::CodexCli => Ok(vec![account.join("sy.config.toml")]),
        Harness::Claude => Ok(vec![account.join("settings.json")]),
        _ => harness::paths(tool),
    }
}

pub fn add(tool: Harness, name: &str) -> Result<String, String> {
    if name.is_empty()
        || name.len() > 64
        || !name
            .bytes()
            .all(|b| b.is_ascii_alphanumeric() || b == b'-' || b == b'_')
    {
        return Err("Account names need 1–64 letters, numbers, hyphens, or underscores.".into());
    }
    let root = root(tool)?;
    harness::binary(tool).ok_or("Install the selected harness first.")?;
    std::fs::create_dir_all(&root).map_err(|e| e.to_string())?;
    let path = root.join(name);
    #[cfg(unix)]
    {
        use std::os::unix::fs::DirBuilderExt;
        std::fs::DirBuilder::new()
            .mode(0o700)
            .create(&path)
            .map_err(|e| {
                format!(
                    "Create account: {e}. \
                     Pick an existing account after Refresh, or choose a new name."
                )
            })?;
    }
    #[cfg(not(unix))]
    std::fs::create_dir(&path).map_err(|e| e.to_string())?;
    let mut pending = PendingAccount(Some(path.clone()));
    login(tool, &path, name)?;
    pending.0 = None;
    Ok(format!(
        "Opened the harness's login in Terminal for account {name}. Complete login, \
         click Refresh, and select this account. Switchyard does not read the login tokens. \
         The selected account applies to new sessions only. Account directory: {}",
        path.display()
    ))
}

pub fn login(tool: Harness, path: &Path, name: &str) -> Result<String, String> {
    validate(tool, path)?;
    let binary = harness::binary(tool).ok_or("Install the selected harness first.")?;
    let variable = match tool {
        Harness::CodexCli => "CODEX_HOME",
        Harness::Claude => "CLAUDE_CONFIG_DIR",
        _ => return Err("Choose a supported harness.".into()),
    };
    #[cfg(windows)]
    crate::windows::open_terminal(crate::windows::TerminalJob {
        binary: binary.clone(),
        args: match tool {
            Harness::CodexCli => vec!["login".into()],
            _ => vec!["auth".into(), "login".into()],
        },
        directory: None,
        environment: vec![(variable.into(), path.display().to_string())],
        remove_environment: vec![],
    })?;
    #[cfg(not(windows))]
    {
        let login = match tool {
            Harness::CodexCli => "login",
            _ => "auth login",
        };
        let script = format!(
            "#!/usr/bin/env bash\n\
             rm -- \"$0\"\n\
             export PATH=\"/opt/homebrew/bin:/usr/local/bin:$PATH\"\n\
             export {variable}={}\n\
             {} {login}",
            crate::sessions::quote(&path.display().to_string()),
            crate::sessions::quote(&binary.display().to_string())
        );
        crate::server::open_terminal_script("switchyard-login-", &script)?;
    }
    Ok(format!(
        "Opened login in Terminal for account {name}. Finish login in the harness. \
         Login status remains unknown until the harness confirms it."
    ))
}

pub fn archive(tool: Harness, path: &Path) -> Result<String, String> {
    validate(tool, path)?;
    let archived = path.with_file_name(format!(".archived-{}", uuid::Uuid::now_v7()));
    std::fs::rename(path, &archived).map_err(|error| error.to_string())?;
    Ok(format!(
        "Archived the account folder at {}. Login files are preserved. \
         Existing sessions may still use the old directory and need a new login.",
        archived.display()
    ))
}

#[cfg(all(test, unix))]
mod tests {
    use super::*;

    // The subprocess isolates HOME so parallel tests keep their own settings.
    #[cfg(unix)]
    #[test]
    fn symlinked_account_roots_are_not_listed_or_used_for_login() {
        if std::env::var_os("SWITCHYARD_ACCOUNT_FIXTURE").is_some() {
            assert!(list(Harness::CodexCli).is_empty());
            assert!(discover(Harness::CodexCli).is_err());
            assert!(add(Harness::CodexCli, "new").is_err());
            let path = crate::config::expand_home(Path::new("~/.switchyard/accounts/codex/named"))
                .expect("home");
            assert!(validate(Harness::CodexCli, &path).is_err());
            return;
        }
        let dir = tempfile::tempdir().expect("fixture");
        let home = dir.path().join("home");
        let target = dir.path().join("target");
        std::fs::create_dir(&home).expect("home");
        std::fs::create_dir_all(target.join("accounts/codex/named")).expect("accounts");
        std::os::unix::fs::symlink(&target, home.join(".switchyard")).expect("symlink");
        let output = std::process::Command::new(std::env::current_exe().expect("runner"))
            .args([
                "--exact",
                "accounts::tests::symlinked_account_roots_are_not_listed_or_used_for_login",
            ])
            .env("SWITCHYARD_ACCOUNT_FIXTURE", "1")
            .env("HOME", &home)
            .output()
            .expect("child");
        assert!(
            output.status.success(),
            "{}",
            String::from_utf8_lossy(&output.stdout)
        );
        assert!(!target.join("accounts/codex/new").exists());
    }
}