@pikecode/api-key-manager 1.0.20 → 1.0.21

package/bin/akm.js

@@ -61,9 +61,12 @@ program
 program
   .command('list')
   .description('列出所有API密钥配置')
-  .action(async () => {
+  .option('--codex', '仅显示 Codex CLI 供应商')
+  .option('--claude', '仅显示 Claude Code 供应商')
+  .action(async (options) => {
     try {
-      await registry.executeCommand('list');
+      const filter = options.codex ? 'codex' : (options.claude ? 'claude' : null);
+      await registry.executeCommand('list', filter);
     } catch (error) {
       console.error(chalk.red('❌ 列表失败:'), error.message);
       process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikecode/api-key-manager",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "A CLI tool for managing and switching multiple API provider configurations",
   "main": "src/index.js",
   "bin": {

package/src/commands/add.js

@@ -194,6 +194,16 @@ class ProviderAdder extends BaseCommand {
             return true;
           }
         },
+        {
+          type: 'list',
+          name: 'ideName',
+          message: '选择要管理的 IDE:',
+          choices: [
+            { name: 'Claude Code (Anthropic)', value: 'claude' },
+            { name: 'Codex CLI (OpenAI)', value: 'codex' }
+          ],
+          default: 'claude'
+        },
         {
           type: 'list',
           name: 'authMode',
@@ -203,7 +213,8 @@ class ProviderAdder extends BaseCommand {
             { name: '🔐 认证令牌模式 (仅 ANTHROPIC_AUTH_TOKEN) - 适用于某些服务商', value: 'auth_token' },
             { name: '🌐 OAuth令牌模式 (CLAUDE_CODE_OAUTH_TOKEN) - 适用于官方Claude Code', value: 'oauth_token' }
           ],
-          default: 'api_key'
+          default: 'api_key',
+          when: (answers) => answers.ideName !== 'codex'
         },
         {
           type: 'list',
@@ -214,7 +225,7 @@ class ProviderAdder extends BaseCommand {
             { name: '🔐 ANTHROPIC_AUTH_TOKEN - 认证令牌', value: 'auth_token' }
           ],
           default: 'api_key',
-          when: (answers) => answers.authMode === 'api_key'
+          when: (answers) => answers.ideName !== 'codex' && answers.authMode === 'api_key'
         },
         {
           type: 'input',
@@ -238,7 +249,7 @@ class ProviderAdder extends BaseCommand {
             if (error) return error;
             return true;
           },
-          when: (answers) => answers.authMode === 'api_key' || answers.authMode === 'auth_token'
+          when: (answers) => answers.ideName !== 'codex' && (answers.authMode === 'api_key' || answers.authMode === 'auth_token')
         },
         {
           type: 'input',
@@ -261,6 +272,33 @@ class ProviderAdder extends BaseCommand {
             if (error) return error;
             return true;
           }
+          ,
+          when: (answers) => answers.ideName !== 'codex'
+        },
+        {
+          type: 'input',
+          name: 'baseUrl',
+          message: '请输入 OpenAI API 基础URL (如使用官方API可留空):',
+          default: '',
+          validate: (input) => {
+            if (!input) return true;
+            const error = validator.validateUrl(input);
+            if (error) return error;
+            return true;
+          },
+          when: (answers) => answers.ideName === 'codex'
+        },
+        {
+          type: 'input',
+          name: 'authToken',
+          message: '请输入 OpenAI API Key (OPENAI_API_KEY):',
+          validate: (input) => {
+            if (!input) return 'API Key 不能为空';
+            const error = validator.validateToken(input);
+            if (error) return error;
+            return true;
+          },
+          when: (answers) => answers.ideName === 'codex'
         },
         {
           type: 'confirm',
@@ -272,19 +310,27 @@ class ProviderAdder extends BaseCommand {
           type: 'confirm',
           name: 'configureLaunchArgs',
           message: '是否配置启动参数?',
-          default: false
+          default: false,
+          when: (answers) => answers.ideName !== 'codex'
         },
         {
           type: 'confirm',
           name: 'configureModels',
           message: '是否配置模型参数?',
-          default: false
+          default: false,
+          when: (answers) => answers.ideName !== 'codex'
         }
       ]);
 
       // 移除 ESC 键监听
       this.removeESCListener(escListener);
       
+      if (answers.ideName === 'codex') {
+        answers.authMode = 'openai_api_key';
+        answers.tokenType = null;
+        answers.codexFiles = null;
+      }
+
       await this.saveProvider(answers);
     } catch (error) {
       // 移除 ESC 键监听
@@ -315,10 +361,12 @@ class ProviderAdder extends BaseCommand {
 
       await this.configManager.addProvider(answers.name, {
         displayName: answers.displayName || answers.name,
+        ideName: answers.ideName || 'claude',
         baseUrl: answers.baseUrl,
         authToken: answers.authToken,
         authMode: answers.authMode,
         tokenType: answers.tokenType, // 仅在 authMode 为 'api_key' 时使用
+        codexFiles: answers.codexFiles || null,
         launchArgs,
         primaryModel: modelConfig.primaryModel,
         smallFastModel: modelConfig.smallFastModel,
@@ -472,6 +520,18 @@ class ProviderAdder extends BaseCommand {
     console.log(chalk.gray(`  名称: ${answers.name}`));
     console.log(chalk.gray(`  显示名称: ${finalDisplayName}`));
 
+    if (answers.ideName === 'codex') {
+      console.log(chalk.gray('  IDE: Codex CLI'));
+      if (answers.baseUrl) {
+        console.log(chalk.gray(`  OPENAI_BASE_URL: ${answers.baseUrl}`));
+      }
+      if (answers.authToken) {
+        console.log(chalk.gray(`  OPENAI_API_KEY: ${answers.authToken}`));
+      }
+      console.log(chalk.green('\n🎉 供应商添加完成！正在返回主界面...'));
+      return;
+    }
+
     const authModeDisplay = {
       api_key: '通用API密钥模式',
       auth_token: '认证令牌模式 (仅 ANTHROPIC_AUTH_TOKEN)',

package/src/commands/current.js

@@ -14,7 +14,7 @@ class CurrentConfig {
       
       if (!currentProvider) {
         Logger.warning('未设置当前供应商');
-        Logger.info('请使用 "cc <供应商名>" 切换供应商');
+        Logger.info('请使用 "akm <供应商名>" 切换供应商');
         return;
       }
 
@@ -24,6 +24,29 @@ class CurrentConfig {
       console.log(chalk.green(`供应商: ${currentProvider.displayName}`));
       console.log(chalk.gray(`内部名称: ${currentProvider.name}`));
 
+      if (currentProvider.ideName === 'codex') {
+        console.log(chalk.gray('IDE: Codex CLI'));
+        if (currentProvider.baseUrl) {
+          console.log(chalk.gray(`OPENAI_BASE_URL: ${currentProvider.baseUrl}`));
+        }
+        if (currentProvider.authToken) {
+          console.log(chalk.gray(`OPENAI_API_KEY: ${currentProvider.authToken}`));
+        }
+        console.log(chalk.gray(`创建时间: ${new Date(currentProvider.createdAt).toLocaleString()}`));
+        console.log(chalk.gray(`最后使用: ${new Date(currentProvider.lastUsed).toLocaleString()}`));
+        console.log(chalk.gray('═'.repeat(60)));
+
+        console.log(chalk.blue('\n🔧 环境变量设置:'));
+        if (currentProvider.baseUrl) {
+          console.log(chalk.gray(`set OPENAI_BASE_URL=${currentProvider.baseUrl}`));
+        }
+        if (currentProvider.authToken) {
+          console.log(chalk.gray(`set OPENAI_API_KEY=${currentProvider.authToken}`));
+        }
+        console.log(chalk.gray('codex'));
+        return;
+      }
+
       // 显示认证模式
       const authModeDisplay = {
         api_key: '通用API密钥模式',
@@ -91,4 +114,4 @@ async function currentCommand() {
   await current.show();
 }
 
-module.exports = { currentCommand, CurrentConfig };
+module.exports = { currentCommand, CurrentConfig };

package/src/commands/edit.js

@@ -64,6 +64,8 @@ class ProviderEditor extends BaseCommand {
     console.log(UIHelper.createTooltip('请更新供应商配置信息。按 Enter 键接受默认值。'));
     console.log();
 
+    const isCodex = providerToEdit.ideName === 'codex';
+
     const escListener = this.createESCListener(() => {
       Logger.info('取消编辑供应商。');
       const { registry } = require('../CommandRegistry');
@@ -73,61 +75,88 @@ class ProviderEditor extends BaseCommand {
     try {
       let answers;
       try {
-        answers = await this.prompt([
+        const questions = [
           {
             type: 'input',
             name: 'displayName',
             message: '供应商显示名称:',
             default: providerToEdit.displayName,
             validate: (input) => validator.validateDisplayName(input) || true,
-          },
-          {
-            type: 'list',
-            name: 'authMode',
-            message: '认证模式:',
-            choices: [
-              { name: '🔑 通用API密钥模式 - 支持 ANTHROPIC_API_KEY 和 ANTHROPIC_AUTH_TOKEN', value: 'api_key' },
-              { name: '🔐 认证令牌模式 (仅 ANTHROPIC_AUTH_TOKEN) - 适用于某些服务商', value: 'auth_token' },
-              { name: '🌐 OAuth令牌模式 (CLAUDE_CODE_OAUTH_TOKEN) - 适用于官方Claude Code', value: 'oauth_token' },
-            ],
-            default: providerToEdit.authMode,
-          },
-          {
-            type: 'list',
-            name: 'tokenType',
-            message: 'Token类型:',
-            choices: [
-              { name: '🔑 ANTHROPIC_API_KEY - 通用API密钥', value: 'api_key' },
-              { name: '🔐 ANTHROPIC_AUTH_TOKEN - 认证令牌', value: 'auth_token' }
-            ],
-            default: providerToEdit.tokenType || 'api_key',
-            when: (answers) => answers.authMode === 'api_key'
-          },
-          {
-            type: 'input',
-            name: 'baseUrl',
-            message: 'API基础URL:',
-            default: providerToEdit.baseUrl,
-            validate: (input) => validator.validateUrl(input) || true,
-            when: (answers) => answers.authMode === 'api_key' || answers.authMode === 'auth_token',
-          },
-          {
-            type: 'input',
-            name: 'authToken',
-            message: (answers) => {
-              switch (answers.authMode) {
-                case 'api_key':
-                  const tokenTypeLabel = answers.tokenType === 'auth_token' ? 'ANTHROPIC_AUTH_TOKEN' : 'ANTHROPIC_API_KEY';
-                  return `Token (${tokenTypeLabel}):`;
-                case 'auth_token': return '认证令牌 (ANTHROPIC_AUTH_TOKEN):';
-                case 'oauth_token': return 'OAuth令牌 (CLAUDE_CODE_OAUTH_TOKEN):';
-                default: return '认证令牌:';
+          }
+        ];
+
+        if (isCodex) {
+          questions.push(
+            {
+              type: 'input',
+              name: 'baseUrl',
+              message: 'OpenAI API 基础URL (留空使用官方API):',
+              default: providerToEdit.baseUrl || '',
+              validate: (input) => {
+                if (!input) return true;
+                return validator.validateUrl(input) || true;
               }
             },
-            default: providerToEdit.authToken,
-            validate: (input) => validator.validateToken(input) || true,
-          },
-          {
+            {
+              type: 'input',
+              name: 'authToken',
+              message: 'OpenAI API Key (OPENAI_API_KEY):',
+              default: providerToEdit.authToken,
+              validate: (input) => {
+                if (!input) return 'API Key 不能为空';
+                return validator.validateToken(input) || true;
+              }
+            }
+          );
+        } else {
+          questions.push(
+            {
+              type: 'list',
+              name: 'authMode',
+              message: '认证模式:',
+              choices: [
+                { name: '🔑 通用API密钥模式 - 支持 ANTHROPIC_API_KEY 和 ANTHROPIC_AUTH_TOKEN', value: 'api_key' },
+                { name: '🔐 认证令牌模式 (仅 ANTHROPIC_AUTH_TOKEN) - 适用于某些服务商', value: 'auth_token' },
+                { name: '🌐 OAuth令牌模式 (CLAUDE_CODE_OAUTH_TOKEN) - 适用于官方Claude Code', value: 'oauth_token' },
+              ],
+              default: providerToEdit.authMode,
+            },
+            {
+              type: 'list',
+              name: 'tokenType',
+              message: 'Token类型:',
+              choices: [
+                { name: '🔑 ANTHROPIC_API_KEY - 通用API密钥', value: 'api_key' },
+                { name: '🔐 ANTHROPIC_AUTH_TOKEN - 认证令牌', value: 'auth_token' }
+              ],
+              default: providerToEdit.tokenType || 'api_key',
+              when: (answers) => answers.authMode === 'api_key'
+            },
+            {
+              type: 'input',
+              name: 'baseUrl',
+              message: 'API基础URL:',
+              default: providerToEdit.baseUrl,
+              validate: (input) => validator.validateUrl(input) || true,
+              when: (answers) => answers.authMode === 'api_key' || answers.authMode === 'auth_token',
+            },
+            {
+              type: 'input',
+              name: 'authToken',
+              message: (answers) => {
+                switch (answers.authMode) {
+                  case 'api_key':
+                    const tokenTypeLabel = answers.tokenType === 'auth_token' ? 'ANTHROPIC_AUTH_TOKEN' : 'ANTHROPIC_API_KEY';
+                    return `Token (${tokenTypeLabel}):`;
+                  case 'auth_token': return '认证令牌 (ANTHROPIC_AUTH_TOKEN):';
+                  case 'oauth_token': return 'OAuth令牌 (CLAUDE_CODE_OAUTH_TOKEN):';
+                  default: return '认证令牌:';
+                }
+              },
+              default: providerToEdit.authToken,
+              validate: (input) => validator.validateToken(input) || true,
+            },
+            {
               type: 'checkbox',
               name: 'launchArgs',
               message: '启动参数:',
@@ -136,8 +165,11 @@ class ProviderEditor extends BaseCommand {
                 value: arg.name,
                 checked: providerToEdit.launchArgs && providerToEdit.launchArgs.includes(arg.name),
               })),
-          },
-        ]);
+            }
+          );
+        }
+
+        answers = await this.prompt(questions);
       } catch (error) {
         this.removeESCListener(escListener);
         if (this.isEscCancelled(error)) {
@@ -147,6 +179,7 @@ class ProviderEditor extends BaseCommand {
       }
 
       this.removeESCListener(escListener);
+
       await this.saveProvider(providerToEdit.name, answers);
 
     } catch (error) {
@@ -160,19 +193,39 @@ class ProviderEditor extends BaseCommand {
 
   async saveProvider(name, answers) {
     try {
-      // Re-use addProvider which can overwrite existing providers
-      await this.configManager.addProvider(name, {
-        displayName: answers.displayName,
-        baseUrl: answers.baseUrl,
-        authToken: answers.authToken,
-        authMode: answers.authMode,
-        tokenType: answers.tokenType, // 仅在 authMode 为 'api_key' 时使用
-        launchArgs: answers.launchArgs,
-        // Retain original model settings unless we add editing for them
-        primaryModel: this.configManager.getProvider(name).models.primary,
-        smallFastModel: this.configManager.getProvider(name).models.smallFast,
-        setAsDefault: false, // Don't change default status on edit
-      });
+      const existingProvider = this.configManager.getProvider(name);
+      const ideName = existingProvider?.ideName || 'claude';
+
+      if (ideName === 'codex') {
+        await this.configManager.addProvider(name, {
+          displayName: answers.displayName,
+          ideName: 'codex',
+          authMode: 'openai_api_key',
+          baseUrl: answers.baseUrl || null,
+          authToken: answers.authToken,
+          tokenType: null,
+          codexFiles: null,
+          launchArgs: existingProvider.launchArgs || [],
+          primaryModel: existingProvider.models?.primary || null,
+          smallFastModel: existingProvider.models?.smallFast || null,
+          setAsDefault: false
+        });
+      } else {
+        // Re-use addProvider which can overwrite existing providers
+        await this.configManager.addProvider(name, {
+          displayName: answers.displayName,
+          ideName,
+          baseUrl: answers.baseUrl,
+          authToken: answers.authToken,
+          authMode: answers.authMode,
+          tokenType: answers.tokenType, // 仅在 authMode 为 'api_key' 时使用
+          launchArgs: answers.launchArgs,
+          // Retain original model settings unless we add editing for them
+          primaryModel: existingProvider.models.primary,
+          smallFastModel: existingProvider.models.smallFast,
+          setAsDefault: false, // Don't change default status on edit
+        });
+      }
 
       Logger.success(`供应商 '${answers.displayName}' 更新成功！`);
 

package/src/commands/list.js

@@ -9,20 +9,34 @@ class ProviderLister {
     this.statusChecker = new ProviderStatusChecker();
   }
 
-  async list() {
+  async list(filter = null) {
     try {
       await this.configManager.ensureLoaded();
-      const providers = this.configManager.listProviders();
+      let providers = this.configManager.listProviders();
       const currentProvider = this.configManager.getCurrentProvider();
+
+      // 应用过滤器
+      if (filter === 'codex') {
+        providers = providers.filter(p => p.ideName === 'codex');
+      } else if (filter === 'claude') {
+        providers = providers.filter(p => p.ideName !== 'codex');
+      }
+
       const statusMap = await this.statusChecker.checkAll(providers);
 
       if (providers.length === 0) {
-        Logger.warning('暂无配置的供应商');
+        if (filter) {
+          const filterName = filter === 'codex' ? 'Codex CLI' : 'Claude Code';
+          Logger.warning(`暂无 ${filterName} 供应商配置`);
+        } else {
+          Logger.warning('暂无配置的供应商');
+        }
         Logger.info('请使用 "akm add" 添加供应商配置');
         return;
       }
 
-      console.log(chalk.blue('\n📋 供应商列表:'));
+      const titleSuffix = filter === 'codex' ? ' (Codex CLI)' : (filter === 'claude' ? ' (Claude Code)' : '');
+      console.log(chalk.blue(`\n📋 供应商列表${titleSuffix}:`));
       console.log(chalk.gray('═'.repeat(60)));
 
       providers.forEach((provider, index) => {
@@ -35,39 +49,49 @@ class ProviderLister {
 
         console.log(`${status} ${availabilityIcon} ${nameColor(provider.name)} (${provider.displayName}) - ${availabilityText}`);
 
-        // 显示认证模式
-        const authModeDisplay = {
-          api_key: '通用API密钥模式',
-          auth_token: '认证令牌模式',
-          oauth_token: 'OAuth令牌模式'
-        };
-        console.log(chalk.gray(`   认证模式: ${authModeDisplay[provider.authMode] || provider.authMode}`));
-
-        // 根据不同模式显示对应的环境变量名称
-        if (provider.authMode === 'oauth_token') {
-          // OAuth 模式
-          if (provider.authToken) {
-            console.log(chalk.gray(`   CLAUDE_CODE_OAUTH_TOKEN: ${provider.authToken}`));
-          }
-          if (provider.baseUrl) {
-            console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
-          }
-        } else if (provider.authMode === 'api_key') {
-          // API Key 模式
+        if (provider.ideName === 'codex') {
+          console.log(chalk.gray('   IDE: Codex CLI'));
           if (provider.baseUrl) {
-            console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
+            console.log(chalk.gray(`   OPENAI_BASE_URL: ${provider.baseUrl}`));
           }
           if (provider.authToken) {
-            const tokenEnvName = provider.tokenType === 'auth_token' ? 'ANTHROPIC_AUTH_TOKEN' : 'ANTHROPIC_API_KEY';
-            console.log(chalk.gray(`   ${tokenEnvName}: ${provider.authToken}`));
+            console.log(chalk.gray(`   OPENAI_API_KEY: ${provider.authToken}`));
           }
         } else {
-          // auth_token 模式
-          if (provider.baseUrl) {
-            console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
-          }
-          if (provider.authToken) {
-            console.log(chalk.gray(`   ANTHROPIC_AUTH_TOKEN: ${provider.authToken}`));
+          // 显示认证模式
+          const authModeDisplay = {
+            api_key: '通用API密钥模式',
+            auth_token: '认证令牌模式',
+            oauth_token: 'OAuth令牌模式'
+          };
+          console.log(chalk.gray(`   认证模式: ${authModeDisplay[provider.authMode] || provider.authMode}`));
+
+          // 根据不同模式显示对应的环境变量名称
+          if (provider.authMode === 'oauth_token') {
+            // OAuth 模式
+            if (provider.authToken) {
+              console.log(chalk.gray(`   CLAUDE_CODE_OAUTH_TOKEN: ${provider.authToken}`));
+            }
+            if (provider.baseUrl) {
+              console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
+            }
+          } else if (provider.authMode === 'api_key') {
+            // API Key 模式
+            if (provider.baseUrl) {
+              console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
+            }
+            if (provider.authToken) {
+              const tokenEnvName = provider.tokenType === 'auth_token' ? 'ANTHROPIC_AUTH_TOKEN' : 'ANTHROPIC_API_KEY';
+              console.log(chalk.gray(`   ${tokenEnvName}: ${provider.authToken}`));
+            }
+          } else {
+            // auth_token 模式
+            if (provider.baseUrl) {
+              console.log(chalk.gray(`   ANTHROPIC_BASE_URL: ${provider.baseUrl}`));
+            }
+            if (provider.authToken) {
+              console.log(chalk.gray(`   ANTHROPIC_AUTH_TOKEN: ${provider.authToken}`));
+            }
           }
         }
 
@@ -132,9 +156,9 @@ class ProviderLister {
   }
 }
 
-async function listCommand() {
+async function listCommand(filter = null) {
   const lister = new ProviderLister();
-  await lister.list();
+  await lister.list(filter);
 }
 
 module.exports = { listCommand, ProviderLister };

package/src/commands/switch.js

@@ -4,6 +4,7 @@ const chalk = require('chalk');
 const Choices = require('inquirer/lib/objects/choices');
 const { ConfigManager } = require('../config');
 const { executeWithEnv } = require('../utils/env-launcher');
+const { executeCodexWithEnv } = require('../utils/codex-launcher');
 const { Logger } = require('../utils/logger');
 const { UIHelper } = require('../utils/ui-helper');
 const { findSettingsConflict, backupSettingsFile, clearConflictKeys, saveSettingsFile } = require('../utils/claude-settings');
@@ -34,6 +35,10 @@ class EnvSwitcher extends BaseCommand {
     try {
       this.clearScreen();
       const provider = await this.validateProvider(providerName);
+      if (provider.ideName === 'codex') {
+        // Codex CLI 使用环境变量注入方式启动，直接跳过参数选择
+        return await this.launchProvider(provider, provider.launchArgs || []);
+      }
       const availableArgs = this.getAvailableLaunchArgs();
       
       console.log(UIHelper.createTitle('启动配置', UIHelper.icons.launch));
@@ -198,15 +203,20 @@ class EnvSwitcher extends BaseCommand {
 
   async launchProvider(provider, selectedLaunchArgs) {
     try {
-      // 执行 Claude Code 设置兼容性检查
-      const shouldContinue = await this.ensureClaudeSettingsCompatibility(provider);
-      if (!shouldContinue) {
-        return;
+      const isCodex = provider.ideName === 'codex';
+
+      // Claude Code 才需要检测设置冲突
+      if (!isCodex) {
+        const shouldContinue = await this.ensureClaudeSettingsCompatibility(provider);
+        if (!shouldContinue) {
+          return;
+        }
       }
 
       this.clearScreen();
       console.log(UIHelper.createTitle('正在启动', UIHelper.icons.loading));
       console.log();
+      const ideDisplayName = isCodex ? 'Codex CLI' : 'Claude Code';
       console.log(UIHelper.createCard('目标供应商', UIHelper.formatProvider(provider), UIHelper.icons.launch));
 
       if (selectedLaunchArgs.length > 0) {
@@ -228,11 +238,15 @@ class EnvSwitcher extends BaseCommand {
 
         UIHelper.clearLoadingAnimation(loadingInterval);
 
-        console.log(UIHelper.createCard('准备就绪', '环境配置完成，正在启动 🚀 Claude Code...', UIHelper.icons.success));
+        console.log(UIHelper.createCard('准备就绪', `环境配置完成，正在启动 🚀 ${ideDisplayName}...`, UIHelper.icons.success));
         console.log();
 
-        // 设置环境变量并启动 Claude Code
-        await executeWithEnv(provider, selectedLaunchArgs);
+        if (isCodex) {
+          await executeCodexWithEnv(provider, selectedLaunchArgs);
+        } else {
+          // 设置环境变量并启动 Claude Code
+          await executeWithEnv(provider, selectedLaunchArgs);
+        }
 
       } catch (error) {
         UIHelper.clearLoadingAnimation(loadingInterval);

package/src/utils/codex-files.js

@@ -0,0 +1,120 @@
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+const CODEX_DIR_NAME = '.codex';
+const CONFIG_TOML_FILE = 'config.toml';
+const AUTH_JSON_FILE = 'auth.json';
+const BACKUP_DIR_NAME = 'akm-backups';
+
+function resolveCodexHome() {
+  return process.env.CODEX_HOME || path.join(os.homedir(), CODEX_DIR_NAME);
+}
+
+function buildCodexPaths(codexHome = resolveCodexHome()) {
+  return {
+    codexHome,
+    configTomlPath: path.join(codexHome, CONFIG_TOML_FILE),
+    authJsonPath: path.join(codexHome, AUTH_JSON_FILE)
+  };
+}
+
+function timestampSuffix() {
+  const now = new Date();
+  const pad = (num) => String(num).padStart(2, '0');
+  return [
+    now.getFullYear(),
+    pad(now.getMonth() + 1),
+    pad(now.getDate()),
+    '_',
+    pad(now.getHours()),
+    pad(now.getMinutes()),
+    pad(now.getSeconds())
+  ].join('');
+}
+
+async function ensureCodexHome(codexHome = resolveCodexHome()) {
+  await fs.ensureDir(codexHome);
+  return codexHome;
+}
+
+async function setSecurePermissions(filePath) {
+  if (process.platform === 'win32') {
+    return;
+  }
+  try {
+    await fs.chmod(filePath, 0o600);
+  } catch {
+    // 忽略权限设置失败
+  }
+}
+
+async function readCodexFiles(codexHome = resolveCodexHome()) {
+  const { configTomlPath, authJsonPath } = buildCodexPaths(codexHome);
+  const configToml = await fs.pathExists(configTomlPath)
+    ? await fs.readFile(configTomlPath, 'utf8')
+    : null;
+  const authJson = await fs.pathExists(authJsonPath)
+    ? await fs.readFile(authJsonPath, 'utf8')
+    : null;
+
+  return {
+    codexHome,
+    configToml,
+    authJson
+  };
+}
+
+async function backupCodexFiles(codexHome = resolveCodexHome()) {
+  const { configTomlPath, authJsonPath } = buildCodexPaths(codexHome);
+  const hasConfig = await fs.pathExists(configTomlPath);
+  const hasAuth = await fs.pathExists(authJsonPath);
+  if (!hasConfig && !hasAuth) {
+    return null;
+  }
+
+  const backupRoot = path.join(codexHome, BACKUP_DIR_NAME);
+  const backupDir = path.join(backupRoot, `backup-${timestampSuffix()}`);
+  await fs.ensureDir(backupDir);
+
+  if (hasConfig) {
+    await fs.copy(configTomlPath, path.join(backupDir, CONFIG_TOML_FILE));
+  }
+  if (hasAuth) {
+    await fs.copy(authJsonPath, path.join(backupDir, AUTH_JSON_FILE));
+  }
+
+  return backupDir;
+}
+
+async function applyCodexProfile(profile, options = {}) {
+  if (!profile || (profile.configToml == null && profile.authJson == null)) {
+    throw new Error('Codex 配置为空，无法切换');
+  }
+
+  const codexHome = await ensureCodexHome(profile.codexHome || options.codexHome);
+  const { configTomlPath, authJsonPath } = buildCodexPaths(codexHome);
+
+  const backupDir = await backupCodexFiles(codexHome);
+
+  if (profile.configToml != null) {
+    await fs.writeFile(configTomlPath, profile.configToml, 'utf8');
+    await setSecurePermissions(configTomlPath);
+  }
+
+  if (profile.authJson != null) {
+    await fs.writeFile(authJsonPath, profile.authJson, 'utf8');
+    await setSecurePermissions(authJsonPath);
+  }
+
+  return { codexHome, backupDir };
+}
+
+module.exports = {
+  resolveCodexHome,
+  buildCodexPaths,
+  readCodexFiles,
+  applyCodexProfile,
+  backupCodexFiles
+};
+

package/src/utils/codex-launcher.js

@@ -0,0 +1,121 @@
+const spawn = require('cross-spawn');
+
+/**
+ * 清理环境变量值，移除危险字符
+ * @param {string} value - 要清理的值
+ * @returns {string} 清理后的值
+ */
+function sanitizeEnvValue(value) {
+  if (typeof value !== 'string') {
+    throw new Error('环境变量值必须是字符串');
+  }
+
+  // 移除控制字符
+  let cleaned = value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, '');
+
+  // 检测可能的 shell 命令注入
+  if (/[;&|`$()]/.test(cleaned)) {
+    throw new Error('环境变量值包含潜在不安全的字符');
+  }
+
+  return cleaned;
+}
+
+function clearTerminal() {
+  if (!process.stdout || typeof process.stdout.write !== 'function') {
+    return;
+  }
+
+  try {
+    process.stdout.write('\x1bc');
+  } catch (error) {
+    // 某些终端可能不支持 RIS 序列，忽略即可
+  }
+
+  const sequence = process.platform === 'win32'
+    ? '\x1b[3J\x1b[2J\x1b[0f'
+    : '\x1b[3J\x1b[2J\x1b[H';
+  try {
+    process.stdout.write(sequence);
+  } catch (error) {
+    // 忽略清屏失败
+  }
+}
+
+/**
+ * 构建 Codex CLI 环境变量
+ * @param {object} config - 供应商配置
+ * @returns {object} 环境变量对象
+ */
+function buildCodexEnvVariables(config) {
+  const env = { ...process.env };
+
+  try {
+    // Codex CLI 使用 OpenAI 环境变量
+    if (config.authToken) {
+      env.OPENAI_API_KEY = sanitizeEnvValue(config.authToken);
+    }
+
+    if (config.baseUrl) {
+      env.OPENAI_BASE_URL = sanitizeEnvValue(config.baseUrl);
+    }
+
+    // 支持自定义模型
+    if (config.models && config.models.primary) {
+      env.OPENAI_MODEL = sanitizeEnvValue(config.models.primary);
+    }
+
+    return env;
+  } catch (error) {
+    throw new Error(`配置验证失败: ${error.message}\n请使用 'akm edit ${config.name}' 修复配置`);
+  }
+}
+
+/**
+ * 使用环境变量注入方式执行 Codex CLI
+ * @param {object} config - 供应商配置
+ * @param {string[]} launchArgs - 启动参数
+ * @returns {Promise<void>}
+ */
+async function executeCodexWithEnv(config, launchArgs = []) {
+  if (!config || config.ideName !== 'codex') {
+    throw new Error('无效的 Codex 供应商配置');
+  }
+
+  if (!config.authToken) {
+    throw new Error(`供应商 '${config.name}' 未配置 API Key，请使用 'akm edit ${config.name}' 添加`);
+  }
+
+  const env = buildCodexEnvVariables(config);
+  const args = Array.isArray(launchArgs) ? [...launchArgs] : [];
+
+  clearTerminal();
+
+  console.log('\n启动 Codex CLI...\n');
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('codex', args, {
+      stdio: 'inherit',
+      env,
+      shell: true
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Codex CLI 退出，退出代码: ${code}\n提示: 请检查 API 配置是否正确`));
+      }
+    });
+
+    child.on('error', (error) => {
+      if (error.code === 'ENOENT') {
+        reject(new Error('找不到 codex 命令\n请先安装 Codex CLI: npm i -g @openai/codex 或 brew install --cask codex'));
+      } else {
+        reject(new Error(`启动 Codex CLI 失败: ${error.message}`));
+      }
+    });
+  });
+}
+
+module.exports = { executeCodexWithEnv, buildCodexEnvVariables };

package/src/utils/provider-status-checker.js

@@ -13,6 +13,10 @@ class ProviderStatusChecker {
       return this._result('unknown', '未找到配置', null);
     }
 
+    if (provider.ideName === 'codex') {
+      return this._checkCodex(provider);
+    }
+
     if (provider.authMode === 'oauth_token') {
       return this._result('unknown', '暂不支持 OAuth 令牌检测', null);
     }
@@ -246,6 +250,52 @@ class ProviderStatusChecker {
   _result(state, label, latency) {
     return { state, label, latency };
   }
+
+  async _checkCodex(provider) {
+    if (!provider.authToken) {
+      return this._result('unknown', '未配置 API Key', null);
+    }
+
+    const baseUrl = provider.baseUrl || 'https://api.openai.com/v1';
+    const modelsUrl = `${baseUrl.replace(/\/$/, '')}/models`;
+
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+
+      const start = process.hrtime.bigint();
+      const response = await fetch(modelsUrl, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${provider.authToken}`,
+          'Content-Type': 'application/json'
+        },
+        signal: controller.signal
+      });
+      const latency = Number(process.hrtime.bigint() - start) / 1e6;
+
+      clearTimeout(timeoutId);
+
+      if (response.ok) {
+        return this._result('online', `可用 ${latency.toFixed(0)}ms`, latency);
+      }
+
+      if (response.status === 401 || response.status === 403) {
+        return this._result('offline', `认证失败 (${response.status})`, null);
+      }
+
+      if (response.status >= 500) {
+        return this._result('degraded', `服务异常 (${response.status})`, null);
+      }
+
+      return this._result('offline', `请求失败 (${response.status})`, null);
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        return this._result('offline', '请求超时', null);
+      }
+      return this._result('offline', `检测失败: ${error.message}`, null);
+    }
+  }
 }
 
 module.exports = { ProviderStatusChecker };