Release 0.1.7

Cargo.lock

@@ -232,7 +232,7 @@ dependencies = [
 
 [[package]]
 name = "cdxs"
-version = "0.1.4"
+version = "0.1.7"
 dependencies = [
  "anyhow",
  "axum",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cdxs"
-version = "0.1.4"
+version = "0.1.7"
 edition = "2021"
 description = "Codex account switcher CLI"
 

README.md

@@ -41,15 +41,22 @@ Codex home 的解析顺序：
 
 - `cdxs list`：列出账号，并自动刷新过期配额缓存。
 - `cdxs show`：列出账号，但不请求配额接口。
+- `cdxs alias set <别名> <账号>`：给任意 OAuth 或 API Key 账号设置别名。
+- `cdxs alias list`：列出所有账号别名。
+- `cdxs alias remove <别名或账号>`：删除指定账号的别名。
 - `cdxs switch`：不带参数时自动选择可用配额最优的账号。
-- `cdxs switch <账号>`：切换到指定账号。
+- `cdxs switch <账号或别名>`：切换到指定账号，OAuth 和 API Key 账号都可通过 alias 切换。
+- `cdxs switch A --model <model> --effort <effort> --name OpenAI`：切换时更新该账号默认模型、思考程度；`--name` 仅用于 API 模式的 provider name。
 - `cdxs ping`：以 5 并发 ping 所有 OAuth 账号，运行最低 reasoning 的最小 `codex exec`，触发 Codex 侧额度状态刷新。
 - `cdxs ping --account <账号>`：指定账号运行最小 `codex exec`；可重复传多个账号。
-- `cdxs login api --key <key> --base-url <url> --switch`：保存 API Key 账号并可选切换；`base-url` 为空时使用 OpenAI 默认 API。
+- `cdxs login --api <key> --base-url <url> --alias A --model <model> --name OpenAI --switch`：保存 API Key 账号并可选切换；`base-url` 为空时使用 OpenAI 默认 API。
+- `cdxs login api --key <key> --base-url <url> --alias A --model <model> --name OpenAI --switch`：同上，保留旧的子命令形式。
 - `cdxs remove <账号>`：删除账号，等价于 `cdxs account remove <账号>`。
 - `cdxs pull`：从同步服务拉取账号状态，等价于 `cdxs sync pull`。
 - `cdxs push`：推送账号状态到同步服务，等价于 `cdxs sync push`。
 
+账号 alias 保存在账号记录里，因此会随 `cdxs push` 推送到同步服务，并随 `cdxs pull` 从同步服务拉取回来。
+
 ## 同步服务
 
 内置同步服务只保存每个用户的账号状态，并提供登录、拉取、推送接口。它同步的是可迁移的 `cdxs` 账号状态，不同步整个 Codex home。

src/account.rs

@@ -8,6 +8,7 @@ use std::path::PathBuf;
 
 use anyhow::{anyhow, Context, Result};
 use chrono::Utc;
+use serde::Serialize;
 use sha2::{Digest, Sha256};
 
 use crate::auth_file;
@@ -16,6 +17,28 @@ use crate::{codex_config, jwt, paths, token};
 
 const DEFAULT_API_BASE_URL: &str = "https://api.openai.com/v1";
 
+#[derive(Debug, Clone, Default)]
+pub struct ApiKeyOptions {
+    pub alias: Option<String>,
+    pub model: Option<String>,
+    pub provider_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct SwitchOptions {
+    pub model: Option<String>,
+    pub reasoning_effort: Option<String>,
+    pub provider_name: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+struct AliasRow {
+    alias: String,
+    account_id: String,
+    email: String,
+    auth_mode: String,
+}
+
 pub fn import_auth(file: Option<PathBuf>, codex_home: Option<PathBuf>, switch: bool) -> Result<()> {
     // Store imported credentials in the main cdxs config, even when the source
     // auth file came from another CODEX_HOME.
@@ -39,12 +62,20 @@ pub fn import_auth(file: Option<PathBuf>, codex_home: Option<PathBuf>, switch: b
     Ok(())
 }
 
-pub fn add_api_key(key: String, base_url: Option<String>, switch: bool) -> Result<()> {
+pub fn add_api_key(
+    key: String,
+    base_url: Option<String>,
+    options: ApiKeyOptions,
+    switch: bool,
+) -> Result<()> {
     let home = paths::codex_home(None)?;
     let mut store = Store::load(&home)?;
-    let account = api_key_account(key, base_url)?;
+    let account = api_key_account(key, base_url, options)?;
     let id = account.id.clone();
     let email = account.email.clone();
+    if let Some(alias) = account.alias.as_deref() {
+        ensure_alias_available(&store, alias, &id)?;
+    }
     store.upsert_account(account);
     if switch {
         store.meta.current_account_id = Some(id.clone());
@@ -92,6 +123,84 @@ pub fn show_accounts(json: bool) -> Result<()> {
     print_accounts(&store, json)
 }
 
+pub fn list_aliases(json: bool) -> Result<()> {
+    let home = paths::codex_home(None)?;
+    let store = Store::load(&home)?;
+    let mut rows = store
+        .accounts
+        .iter()
+        .filter_map(|account| {
+            account.alias.as_ref().map(|alias| AliasRow {
+                alias: alias.clone(),
+                account_id: account.id.clone(),
+                email: alias_target_display(account).to_string(),
+                auth_mode: auth_file::account_auth_mode_name(account).to_string(),
+            })
+        })
+        .collect::<Vec<_>>();
+    rows.sort_by(|left, right| {
+        left.alias
+            .to_ascii_lowercase()
+            .cmp(&right.alias.to_ascii_lowercase())
+            .then_with(|| left.account_id.cmp(&right.account_id))
+    });
+
+    if json {
+        println!("{}", serde_json::to_string_pretty(&rows)?);
+        return Ok(());
+    }
+    if rows.is_empty() {
+        println!("没有设置 alias。");
+        return Ok(());
+    }
+    println!("{:<18} {:<22} {:<10} Account", "Alias", "ID", "Mode");
+    for row in rows {
+        println!(
+            "{:<18} {:<22} {:<10} {}",
+            shorten(&row.alias, 18),
+            shorten(&row.account_id, 22),
+            shorten(&row.auth_mode, 10),
+            row.email
+        );
+    }
+    Ok(())
+}
+
+pub fn set_alias(alias: &str, query: &str) -> Result<()> {
+    let home = paths::codex_home(None)?;
+    let mut store = Store::load(&home)?;
+    let alias = normalize_alias(alias)?;
+    let account_id = find_unique_account_id(&store, query)?;
+    ensure_alias_available(&store, &alias, &account_id)?;
+    let account = store
+        .find_account_mut(&account_id)
+        .ok_or_else(|| anyhow!("账号不存在: {account_id}"))?;
+    let changed = account.alias.as_deref() != Some(alias.as_str());
+    account.alias = Some(alias.clone());
+    if changed {
+        account.updated_at = Utc::now().timestamp();
+    }
+    store.save(&home)?;
+    println!("已设置 alias: {alias} -> {account_id}");
+    Ok(())
+}
+
+pub fn remove_alias(query: &str) -> Result<()> {
+    let home = paths::codex_home(None)?;
+    let mut store = Store::load(&home)?;
+    let account_id = find_unique_account_id(&store, query)?;
+    let account = store
+        .find_account_mut(&account_id)
+        .ok_or_else(|| anyhow!("账号不存在: {account_id}"))?;
+    let Some(alias) = account.alias.take() else {
+        return Err(anyhow!("账号未设置 alias: {account_id}"));
+    };
+    account.updated_at = Utc::now().timestamp();
+    store.save(&home)?;
+    println!("已删除 alias: {alias} ({account_id})");
+    Ok(())
+}
+
 fn print_accounts(store: &Store, json: bool) -> Result<()> {
     if json {
         println!("{}", serde_json::to_string_pretty(&store.accounts)?);
@@ -205,6 +314,7 @@ pub async fn switch_account(
     query: &str,
     codex_home: Option<PathBuf>,
     apply_fingerprint: bool,
+    options: SwitchOptions,
 ) -> Result<()> {
     if apply_fingerprint {
         eprintln!("提示: M1 尚未实现设备指纹应用，已忽略 --apply-fingerprint。");
@@ -215,10 +325,15 @@ pub async fn switch_account(
     let target_home = paths::codex_home(codex_home)?;
     let mut store = Store::load(&config_home)?;
     let account_id = find_unique_account_id(&store, query)?;
+    update_account_switch_options(&mut store, &account_id, &options)?;
     switch_account_id(&mut store, &config_home, &target_home, &account_id).await
 }
 
-pub async fn switch_auto(codex_home: Option<PathBuf>, apply_fingerprint: bool) -> Result<()> {
+pub async fn switch_auto(
+    codex_home: Option<PathBuf>,
+    apply_fingerprint: bool,
+    options: SwitchOptions,
+) -> Result<()> {
     if apply_fingerprint {
         eprintln!("提示: M1 尚未实现设备指纹应用，已忽略 --apply-fingerprint。");
     }
@@ -240,6 +355,7 @@ pub async fn switch_auto(codex_home: Option<PathBuf>, apply_fingerprint: bool) -
         );
     }
     let account_id = best_auto_switch_account(&store)?;
+    update_account_switch_options(&mut store, &account_id, &options)?;
     switch_account_id(&mut store, &config_home, &target_home, &account_id).await?;
     if let Some(account) = store.find_account(&account_id) {
         println!(
@@ -424,7 +540,11 @@ fn account_from_auth(auth: auth_file::CodexAuthFile) -> Result<Account> {
     if auth_file::is_api_key_mode(&auth) {
         let key = auth_file::extract_api_key(&auth)
             .ok_or_else(|| anyhow!("auth.json 缺少 OPENAI_API_KEY"))?;
-        return api_key_account(key, auth_file::api_base_url(&auth));
+        return api_key_account(
+            key,
+            auth_file::api_base_url(&auth),
+            ApiKeyOptions::default(),
+        );
     }
 
     let tokens = auth
@@ -488,6 +608,10 @@ fn oauth_account(tokens: Tokens, account_id_hint: Option<String>) -> Result<Acco
         id,
         email,
         auth_mode: AuthMode::Oauth,
+        alias: None,
+        model: None,
+        reasoning_effort: None,
+        api_provider_name: None,
         plan_type,
         account_id,
         organization_id,
@@ -503,12 +627,19 @@ fn oauth_account(tokens: Tokens, account_id_hint: Option<String>) -> Result<Acco
     })
 }
 
-fn api_key_account(key: String, base_url: Option<String>) -> Result<Account> {
+fn api_key_account(
+    key: String,
+    base_url: Option<String>,
+    options: ApiKeyOptions,
+) -> Result<Account> {
     let key = key.trim();
     if key.is_empty() {
         return Err(anyhow!("API Key 不能为空"));
     }
     let base_url = normalize_api_base_url(base_url);
+    let alias = normalize_optional_field(options.alias);
+    let model = normalize_optional_field(options.model);
+    let provider_name = normalize_optional_field(options.provider_name);
     let id = stable_id("apikey", key, base_url.as_deref(), None);
     let email = api_base_url_display(base_url.as_deref()).to_string();
     let now = Utc::now().timestamp();
@@ -516,6 +647,10 @@ fn api_key_account(key: String, base_url: Option<String>) -> Result<Account> {
         id,
         email,
         auth_mode: AuthMode::ApiKey,
+        alias,
+        model,
+        reasoning_effort: None,
+        api_provider_name: provider_name,
         plan_type: None,
         account_id: None,
         organization_id: None,
@@ -548,7 +683,11 @@ fn stable_id(kind: &str, a: &str, b: Option<&str>, c: Option<&str>) -> String {
 fn find_unique_account_id(store: &Store, query: &str) -> Result<String> {
     // Exact ids are always unambiguous. Email and prefix queries can match both
     // personal and team accounts for the same login email, so reject ambiguity.
-    if let Some(account) = store.accounts.iter().find(|account| account.id == query) {
+    if let Some(account) = store
+        .accounts
+        .iter()
+        .find(|account| account.id == query || account.alias.as_deref() == Some(query))
+    {
         return Ok(account.id.clone());
     }
 
@@ -559,6 +698,11 @@ fn find_unique_account_id(store: &Store, query: &str) -> Result<String> {
         .filter(|account| {
             account_id_matches_query(&account.id, query)
                 || account.email.eq_ignore_ascii_case(query)
+                || account
+                    .alias
+                    .as_deref()
+                    .map(|alias| alias.eq_ignore_ascii_case(query))
+                    .unwrap_or(false)
                 || account
                     .email
                     .to_ascii_lowercase()
@@ -589,6 +733,36 @@ fn find_unique_account_id(store: &Store, query: &str) -> Result<String> {
     }
 }
 
+fn update_account_switch_options(
+    store: &mut Store,
+    account_id: &str,
+    options: &SwitchOptions,
+) -> Result<()> {
+    let Some(account) = store.find_account_mut(account_id) else {
+        return Err(anyhow!("账号不存在: {account_id}"));
+    };
+    let mut changed = false;
+    if let Some(model) = normalize_optional_field(options.model.clone()) {
+        changed |= account.model.as_deref() != Some(model.as_str());
+        account.model = Some(model);
+    }
+    if let Some(reasoning_effort) = normalize_optional_field(options.reasoning_effort.clone()) {
+        changed |= account.reasoning_effort.as_deref() != Some(reasoning_effort.as_str());
+        account.reasoning_effort = Some(reasoning_effort);
+    }
+    if let Some(provider_name) = normalize_optional_field(options.provider_name.clone()) {
+        if account.auth_mode != AuthMode::ApiKey {
+            return Err(anyhow!("--name 仅支持 API Key 账号"));
+        }
+        changed |= account.api_provider_name.as_deref() != Some(provider_name.as_str());
+        account.api_provider_name = Some(provider_name);
+    }
+    if changed {
+        account.updated_at = Utc::now().timestamp();
+    }
+    Ok(())
+}
+
 fn account_id_matches_query(id: &str, query: &str) -> bool {
     id.starts_with(query)
         || id
@@ -682,6 +856,16 @@ fn account_plan_display(account: &Account) -> &str {
 }
 
 fn account_email_display(account: &Account) -> &str {
+    if let Some(alias) = account.alias.as_deref() {
+        alias
+    } else if account.auth_mode == AuthMode::ApiKey {
+        api_base_url_display(account.api_base_url.as_deref())
+    } else {
+        &account.email
+    }
+}
+
+fn alias_target_display(account: &Account) -> &str {
     if account.auth_mode == AuthMode::ApiKey {
         api_base_url_display(account.api_base_url.as_deref())
     } else {
@@ -804,8 +988,14 @@ fn shorten(value: &str, width: usize) -> String {
 
 fn print_account(account: &Account) {
     println!("id: {}", account.id);
+    println!("alias: {}", account.alias.as_deref().unwrap_or("-"));
     println!("email: {}", account_email_display(account));
     println!("auth_mode: {}", auth_file::account_auth_mode_name(account));
+    println!("model: {}", account.model.as_deref().unwrap_or("-"));
+    println!(
+        "reasoning_effort: {}",
+        account.reasoning_effort.as_deref().unwrap_or("-")
+    );
     println!("plan_type: {}", account_plan_display(account));
     println!(
         "account_id: {}",
@@ -820,6 +1010,10 @@ fn print_account(account: &Account) {
             "api_base_url: {}",
             api_base_url_display(account.api_base_url.as_deref())
         );
+        println!(
+            "api_provider_name: {}",
+            account.api_provider_name.as_deref().unwrap_or("-")
+        );
         println!(
             "openai_api_key: {}",
             account
@@ -840,6 +1034,42 @@ fn normalize_api_base_url(base_url: Option<String>) -> Option<String> {
         .map(|value| value.trim_end_matches('/').to_string())
 }
 
+fn normalize_alias(alias: &str) -> Result<String> {
+    let alias = alias.trim();
+    if alias.is_empty() {
+        return Err(anyhow!("alias 不能为空"));
+    }
+    Ok(alias.to_string())
+}
+
+fn normalize_optional_field(value: Option<String>) -> Option<String> {
+    value
+        .as_deref()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
+fn ensure_alias_available(store: &Store, alias: &str, account_id: &str) -> Result<()> {
+    for account in &store.accounts {
+        if account.id == account_id {
+            continue;
+        }
+        if account
+            .alias
+            .as_deref()
+            .map(|existing| existing.eq_ignore_ascii_case(alias))
+            .unwrap_or(false)
+        {
+            return Err(anyhow!("alias 已被使用: {alias} -> {}", account.id));
+        }
+        if account.id.eq_ignore_ascii_case(alias) || account.email.eq_ignore_ascii_case(alias) {
+            return Err(anyhow!("alias 与已有账号冲突: {alias} -> {}", account.id));
+        }
+    }
+    Ok(())
+}
+
 fn mask_api_key(key: &str) -> String {
     let chars = key.chars().collect::<Vec<_>>();
     if chars.len() <= 8 {

src/cli.rs

@@ -45,6 +45,11 @@ pub enum Commands {
         )]
         account: String,
     },
+    /// Manage account aliases.
+    Alias {
+        #[command(subcommand)]
+        command: AliasCommands,
+    },
     /// Switch Codex auth.json to a saved account.
     Switch {
         #[arg(
@@ -58,6 +63,12 @@ pub enum Commands {
         codex_home: Option<PathBuf>,
         #[arg(long)]
         apply_fingerprint: bool,
+        #[arg(long)]
+        model: Option<String>,
+        #[arg(long, alias = "reasoning-effort")]
+        effort: Option<String>,
+        #[arg(long)]
+        name: Option<String>,
     },
     /// Prepare auth, set CODEX_HOME, and execute a command.
     Run(RunArgs),
@@ -102,6 +113,17 @@ pub struct LoginArgs {
     /// Start OpenAI OAuth login for Codex.
     #[command(subcommand)]
     pub command: Option<LoginCommands>,
+    /// Add an API key account directly, for example: cdxs login --api sk-...
+    #[arg(long, value_name = "KEY")]
+    pub api: Option<String>,
+    #[arg(long)]
+    pub base_url: Option<String>,
+    #[arg(long)]
+    pub alias: Option<String>,
+    #[arg(long)]
+    pub model: Option<String>,
+    #[arg(long)]
+    pub name: Option<String>,
     #[arg(long)]
     pub manual: bool,
     #[arg(long, default_value_t = 1455)]
@@ -141,6 +163,12 @@ pub enum LoginCommands {
         #[arg(long)]
         base_url: Option<String>,
         #[arg(long)]
+        alias: Option<String>,
+        #[arg(long)]
+        model: Option<String>,
+        #[arg(long)]
+        name: Option<String>,
+        #[arg(long)]
         switch: bool,
     },
 }
@@ -184,10 +212,36 @@ pub enum AccountCommands {
         #[arg(long)]
         base_url: Option<String>,
         #[arg(long)]
+        alias: Option<String>,
+        #[arg(long)]
+        model: Option<String>,
+        #[arg(long)]
+        name: Option<String>,
+        #[arg(long)]
         switch: bool,
     },
 }
 
+#[derive(Subcommand)]
+pub enum AliasCommands {
+    /// List account aliases.
+    List {
+        #[arg(long)]
+        json: bool,
+    },
+    /// Set or replace an alias for any saved account.
+    Set {
+        alias: String,
+        #[arg(value_name = "ACCOUNT_ID_OR_EMAIL")]
+        account: String,
+    },
+    /// Remove an alias by alias name or account selector.
+    Remove {
+        #[arg(value_name = "ALIAS_OR_ACCOUNT")]
+        alias: String,
+    },
+}
+
 #[derive(Subcommand)]
 pub enum HomeCommands {
     List {

src/codex_config.rs

@@ -14,48 +14,64 @@ const MANAGED_PROVIDER_PREFIX: &str = "cdxs_api_";
 
 pub fn apply_account_provider(codex_home: &Path, account: &Account) -> Result<()> {
     match account.auth_mode {
-        AuthMode::Oauth => clear_managed_provider(codex_home),
+        AuthMode::Oauth => apply_oauth_config(codex_home, account),
         AuthMode::ApiKey => apply_api_key_provider(codex_home, account),
     }
 }
 
-fn apply_api_key_provider(codex_home: &Path, account: &Account) -> Result<()> {
+fn apply_oauth_config(codex_home: &Path, account: &Account) -> Result<()> {
     let path = paths::codex_config_path(codex_home);
-    let mut config = read_config(&path)?;
-    let mut changed = remove_previous_managed_provider(&mut config);
-
-    if let Some(base_url) = account.api_base_url.as_deref().and_then(normalize_base_url) {
-        let provider_id = provider_id(account, &base_url);
-        config.insert(
-            "model_provider".to_string(),
-            Value::String(provider_id.clone()),
-        );
-
-        let providers = table_entry(&mut config, "model_providers");
-        let mut provider = Map::new();
-        provider.insert("name".to_string(), Value::String("cdxs api".to_string()));
-        provider.insert("base_url".to_string(), Value::String(base_url));
-        provider.insert("requires_openai_auth".to_string(), Value::Boolean(true));
-        providers.insert(provider_id, Value::Table(provider));
-        changed = true;
+    if !path.exists() && account.model.is_none() && account.reasoning_effort.is_none() {
+        return Ok(());
     }
-
+    let mut config = read_config(&path)?;
+    let mut changed = apply_common_model_settings(&mut config, account);
+    changed |= remove_previous_managed_provider(&mut config);
     if changed {
         write_config(&path, codex_home, &config)?;
     }
     Ok(())
 }
 
-fn clear_managed_provider(codex_home: &Path) -> Result<()> {
+fn apply_api_key_provider(codex_home: &Path, account: &Account) -> Result<()> {
     let path = paths::codex_config_path(codex_home);
-    if !path.exists() {
-        return Ok(());
-    }
     let mut config = read_config(&path)?;
-    if remove_previous_managed_provider(&mut config) {
-        write_config(&path, codex_home, &config)?;
-    }
-    Ok(())
+    remove_previous_managed_provider(&mut config);
+
+    apply_common_model_settings(&mut config, account);
+
+    let base_url = account
+        .api_base_url
+        .as_deref()
+        .and_then(normalize_base_url)
+        .unwrap_or_else(|| "https://api.openai.com/v1".to_string());
+    let provider_id = provider_id(account, &base_url);
+    config.insert(
+        "model_provider".to_string(),
+        Value::String(provider_id.clone()),
+    );
+
+    let providers = table_entry(&mut config, "model_providers");
+    let mut provider = Map::new();
+    provider.insert(
+        "name".to_string(),
+        Value::String(
+            account
+                .api_provider_name
+                .as_deref()
+                .and_then(normalize_field)
+                .unwrap_or_else(|| "OpenAI".to_string()),
+        ),
+    );
+    provider.insert("base_url".to_string(), Value::String(base_url));
+    provider.insert(
+        "wire_api".to_string(),
+        Value::String("responses".to_string()),
+    );
+    provider.insert("requires_openai_auth".to_string(), Value::Boolean(true));
+    providers.insert(provider_id, Value::Table(provider));
+
+    write_config(&path, codex_home, &config)
 }
 
 fn read_config(path: &Path) -> Result<Map<String, Value>> {
@@ -127,3 +143,32 @@ fn normalize_base_url(value: &str) -> Option<String> {
         Some(value.to_string())
     }
 }
+
+fn apply_common_model_settings(config: &mut Map<String, Value>, account: &Account) -> bool {
+    let mut changed = false;
+    if let Some(model) = account.model.as_deref().and_then(normalize_field) {
+        config.insert("model".to_string(), Value::String(model));
+        changed = true;
+    }
+    if let Some(reasoning_effort) = account
+        .reasoning_effort
+        .as_deref()
+        .and_then(normalize_field)
+    {
+        config.insert(
+            "model_reasoning_effort".to_string(),
+            Value::String(reasoning_effort),
+        );
+        changed = true;
+    }
+    changed
+}
+
+fn normalize_field(value: &str) -> Option<String> {
+    let value = value.trim();
+    if value.is_empty() {
+        None
+    } else {
+        Some(value.to_string())
+    }
+}

src/config_store.rs

@@ -56,6 +56,14 @@ pub struct Account {
     pub email: String,
     pub auth_mode: AuthMode,
     #[serde(default)]
+    pub alias: Option<String>,
+    #[serde(default)]
+    pub model: Option<String>,
+    #[serde(default)]
+    pub reasoning_effort: Option<String>,
+    #[serde(default)]
+    pub api_provider_name: Option<String>,
+    #[serde(default)]
     pub plan_type: Option<String>,
     #[serde(default)]
     pub account_id: Option<String>,
@@ -234,6 +242,11 @@ impl Store {
                     .split_once('_')
                     .map(|(_, suffix)| suffix.starts_with(query))
                     .unwrap_or(false)
+                || account
+                    .alias
+                    .as_deref()
+                    .map(|alias| alias.eq_ignore_ascii_case(query))
+                    .unwrap_or(false)
                 || account.email.eq_ignore_ascii_case(query)
                 || account
                     .email

src/main.rs

@@ -24,8 +24,8 @@ use anyhow::Result;
 use clap::Parser;
 
 use crate::cli::{
-    AccountCommands, Cli, Commands, HomeCommands, ImportCommands, LoginCommands, ServerCommands,
-    ServerUserCommands, SessionCommands, SessionVisibilityCommands, SyncCommands,
+    AccountCommands, AliasCommands, Cli, Commands, HomeCommands, ImportCommands, LoginCommands,
+    ServerCommands, ServerUserCommands, SessionCommands, SessionVisibilityCommands, SyncCommands,
 };
 
 #[tokio::main]
@@ -44,9 +44,36 @@ async fn main() -> Result<()> {
             Some(LoginCommands::Api {
                 key,
                 base_url,
+                alias,
+                model,
+                name,
                 switch,
-            }) => account::add_api_key(key, base_url, switch),
-            None => oauth::login_oauth(args.manual, args.port, args.switch).await,
+            }) => account::add_api_key(
+                key,
+                base_url,
+                account::ApiKeyOptions {
+                    alias,
+                    model,
+                    provider_name: name,
+                },
+                switch,
+            ),
+            None => {
+                if let Some(key) = args.api {
+                    account::add_api_key(
+                        key,
+                        args.base_url,
+                        account::ApiKeyOptions {
+                            alias: args.alias,
+                            model: args.model,
+                            provider_name: args.name,
+                        },
+                        args.switch,
+                    )
+                } else {
+                    oauth::login_oauth(args.manual, args.port, args.switch).await
+                }
+            }
         },
         Commands::Import(args) => match args.command {
             Some(ImportCommands::Auth {
@@ -61,14 +88,27 @@ async fn main() -> Result<()> {
         Commands::Pull { force } => sync_client::pull(force).await,
         Commands::Push { force } => sync_client::push(force).await,
         Commands::Remove { account } => account::remove_account(&account),
+        Commands::Alias { command } => match command {
+            AliasCommands::List { json } => account::list_aliases(json),
+            AliasCommands::Set { alias, account } => account::set_alias(&alias, &account),
+            AliasCommands::Remove { alias } => account::remove_alias(&alias),
+        },
         Commands::Switch {
             account,
             auto,
             codex_home,
             apply_fingerprint,
+            model,
+            effort,
+            name,
         } => {
+            let options = account::SwitchOptions {
+                model,
+                reasoning_effort: effort,
+                provider_name: name,
+            };
             if auto || account.is_none() {
-                account::switch_auto(codex_home, apply_fingerprint).await
+                account::switch_auto(codex_home, apply_fingerprint, options).await
             } else {
                 account::switch_account(
                     account.as_deref().ok_or_else(|| {
@@ -76,6 +116,7 @@ async fn main() -> Result<()> {
                     })?,
                     codex_home,
                     apply_fingerprint,
+                    options,
                 )
                 .await
             }
@@ -109,8 +150,20 @@ async fn main() -> Result<()> {
             AccountCommands::AddApiKey {
                 key,
                 base_url,
+                alias,
+                model,
+                name,
                 switch,
-            } => account::add_api_key(key, base_url, switch),
+            } => account::add_api_key(
+                key,
+                base_url,
+                account::ApiKeyOptions {
+                    alias,
+                    model,
+                    provider_name: name,
+                },
+                switch,
+            ),
         },
         Commands::Home { command } => match command {
             HomeCommands::List { json } => account::list_homes(json),

src/sync_client.rs

@@ -148,8 +148,8 @@ pub async fn remote(json: bool) -> Result<()> {
         return Ok(());
     }
     println!(
-        "{:<22} {:<34} {:<10} {:<12} {}",
-        "ID", "Email", "Mode", "Plan", "Quota"
+        "{:<22} {:<16} {:<34} {:<10} {:<18} {:<12} {}",
+        "ID", "Alias", "Email", "Mode", "Model", "Provider", "Quota"
     );
     for account in &remote_state.accounts {
         let quota = account
@@ -163,11 +163,13 @@ pub async fn remote(json: bool) -> Result<()> {
             })
             .unwrap_or_else(|| "-".to_string());
         println!(
-            "{:<22} {:<34} {:<10} {:<12} {}",
+            "{:<22} {:<16} {:<34} {:<10} {:<18} {:<12} {}",
             shorten(&account.id, 22),
+            shorten(account.alias.as_deref().unwrap_or("-"), 16),
             shorten(account_email_display(account), 34),
             account_auth_mode_name(account),
-            account_plan_display(account),
+            shorten(account.model.as_deref().unwrap_or("-"), 18),
+            shorten(account_provider_display(account), 12),
             quota
         );
     }
@@ -308,6 +310,14 @@ fn account_plan_display(account: &Account) -> &str {
     }
 }
 
+fn account_provider_display(account: &Account) -> &str {
+    if account.auth_mode == crate::config_store::AuthMode::ApiKey {
+        account.api_provider_name.as_deref().unwrap_or("-")
+    } else {
+        account_plan_display(account)
+    }
+}
+
 fn shorten(value: &str, width: usize) -> String {
     if value.chars().count() <= width {
         return value.to_string();