base_parts_ai 1.0.55 → 1.0.57

package/README.md

@@ -1,4 +1,4 @@
-
+
 ## npx 运行
 
 已发布到 npm 仓库后，可以直接运行入口命令：
@@ -7,7 +7,7 @@
 npx base_parts_ai
 ```
 
-无参数时会让用户选择 `jcc`、`jcx` 或 `weds`，再继续执行对应配置流程。
+无参数时会让用户选择 `jcc`、`jcx`、`weds`、`ucx` 或 `jgrok`，再继续执行对应流程。
 
 也可以明确指定工具，适合脚本或需要带参数的场景：
 
@@ -15,6 +15,8 @@ npx base_parts_ai
 npx base_parts_ai jcc
 npx base_parts_ai jcx
 npx base_parts_ai weds
+npx base_parts_ai ucx
+npx base_parts_ai jgrok
 npx base_parts_ai jcc setapi
 npx base_parts_ai jcx setapi
 npx base_parts_ai weds setapi
@@ -27,18 +29,29 @@ npx base_parts_ai --help
 npx base_parts_ai --version
 ```
 
-通过 `base_parts_ai` 入口执行时，会屏蔽 `base_parts_ai` 自身自动升级；`jcc`、`jcx`、`weds` 单独运行行为保持不变。
+通过 `base_parts_ai` 入口执行时，会屏蔽 `base_parts_ai` 自身自动升级；`jcc`、`jcx`、`weds`、`ucx`、`jgrok` 单独运行行为保持不变。
+
+全局安装后也可以直接运行：
+
+```powershell
+ucx
+jgrok
+```
+
+`ucx` 会扫描用户主目录下一层的 `~/.codex` 与 `~/.codex_*`。账号名优先用 `auth.json` 中非空 `OPENAI_API_KEY` 的脱敏短名，否则用 JWT email；不会自动创建空的 `~/.codex`。
+
+`jgrok` 若 `~/.grok/.env` 不存在则写入代理示例并打印绝对路径，请编辑后再运行。已存在则把该文件注入环境变量：本机没有 `grok` 时通过腾讯云 npm 源安装 `@xai-official/grok`（安装不注入环境变量），然后启动 `grok`，用户参数原样透传。
 
 ## 下载发布的包
-https://registry.npmjs.org/base_parts_ai/-/base_parts_ai-1.0.45.tgz
-
-## 然后放在jdwfiles目录下
-https://jdwfiles.oss-cn-hangzhou.aliyuncs.com/npm_pkg/base_parts_ai-1.0.34.tgz
-
-
-# 2.1.34
-User-Agent: claude-cli/2.1.34 (external, cli)
-claude-opus-4-6
-claude-sonnet-4-6
-claude-haiku-4-5-20251001
-
+https://registry.npmjs.org/base_parts_ai/-/base_parts_ai-1.0.57.tgz
+
+## 然后放在jdwfiles目录下
+https://jdwfiles.oss-cn-hangzhou.aliyuncs.com/npm_pkg/base_parts_ai-1.0.34.tgz
+
+
+# 2.1.34
+User-Agent: claude-cli/2.1.34 (external, cli)
+claude-opus-4-6
+claude-sonnet-4-6
+claude-haiku-4-5-20251001
+

package/bin/jgrok.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var os = require('os');
+var path = require('path');
+
+/**
+ * 构建 jgrok 运行配置，只解析主目录
+ * @returns {{ homeDir: string }}
+ */
+function getBuildCfg() {
+    var homeDir = process.env.JCC_TEST_HOME || os.homedir();
+    return { homeDir: homeDir };
+}
+
+/**
+ * 动态加载 lib 下的命令模块，便于本地开发时读取最新文件
+ * @param {string} libName lib 目录下的文件名（不含 .js）
+ * @returns {Function}
+ */
+function loadLib(libName) {
+    var libPath = path.resolve(__dirname, '../lib/' + libName + '.js');
+    delete require.cache[require.resolve(libPath)];
+    return require(libPath);
+}
+
+/**
+ * 运行 jgrok CLI，参数全部透传给 grok，可供命令行直接执行或被 base_parts_ai require 调用
+ * @param {Array<string>} args 用户参数，不包含 node 和脚本路径
+ * @returns {Promise<number>}
+ */
+async function runCli(args) {
+    var buildCfg = getBuildCfg();
+    return await loadLib('jgrok')(args || [], buildCfg);
+}
+
+if (require.main === module) {
+    runCli(process.argv.slice(2)).then(function (code) {
+        process.exit(typeof code === 'number' ? code : 0);
+    }).catch(function (err) {
+        console.error('jgrok 执行失败:', err.message);
+        process.exit(1);
+    });
+}
+
+module.exports = runCli;

package/bin/postinstall.js

@@ -16,5 +16,7 @@ console.log(c.cyan + '  ╔═════════════════
 console.log(c.cyan + '  ║  ' + c.yellow + '安装完成！输入以下命令开始配置：' + c.reset);
 console.log(c.cyan + '  ║    ' + c.green + 'jcc' + c.white + '  配置或安装 ClaudeCode' + c.reset);
 console.log(c.cyan + '  ║    ' + c.green + 'weds' + c.white + ' 配置或安装 weds ClaudeCode' + c.reset);
+console.log(c.cyan + '  ║    ' + c.green + 'ucx' + c.white + '  切换 Codex 账号' + c.reset);
+console.log(c.cyan + '  ║    ' + c.green + 'jgrok' + c.white + ' 带代理环境启动 grok' + c.reset);
 console.log(c.cyan + '  ╚══════════════════════════════════════════╝' + c.reset);
 console.log('');

package/bin/ucx.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var os = require('os');
+var path = require('path');
+var { Command } = require('commander');
+var packageJson = require('../package.json');
+
+/**
+ * 构建 ucx 运行配置，只解析主目录，禁止创建空的 ~/.codex
+ * @returns {{ homeDir: string }}
+ */
+function getBuildCfg() {
+    var homeDir = process.env.JCC_TEST_HOME || os.homedir();
+    return { homeDir: homeDir };
+}
+
+/**
+ * 动态加载 lib 下的命令模块，便于本地开发时读取最新文件
+ * @param {string} libName lib 目录下的文件名（不含 .js）
+ * @returns {Function}
+ */
+function loadLib(libName) {
+    var libPath = path.resolve(__dirname, '../lib/' + libName + '.js');
+    delete require.cache[require.resolve(libPath)];
+    return require(libPath);
+}
+
+/**
+ * 拉取远程配置（含自动升级）后执行账号切换
+ * @returns {Promise<void>}
+ */
+async function runSwitch() {
+    var buildCfg = getBuildCfg();
+    var utils = loadLib('ai_utils');
+    await utils.fetchConfig(buildCfg);
+    await utils.showNotice();
+    await loadLib('ucx')({}, buildCfg);
+}
+
+/**
+ * 运行 ucx CLI，可供命令行直接执行或被 base_parts_ai require 调用
+ * @param {Array<string>} args 用户参数，不包含 node 和脚本路径
+ * @returns {Promise<void>}
+ */
+async function runCli(args) {
+    var cliArgs = (args || []).slice();
+    var program = new Command();
+
+    program
+        .name('ucx')
+        .description('通过目录改名切换 Codex 账号')
+        .version(packageJson.version)
+        .action(async function () {
+            await runSwitch();
+        });
+
+    // 无参数时直接进入切换，避免 commander 空参数不触发根 action
+    if (cliArgs.length <= 0) {
+        await runSwitch();
+        return;
+    }
+
+    // 使用 from:user 避免读取或修改全局 process.argv，便于被主入口 require 调用
+    await program.parseAsync(cliArgs, { from: 'user' });
+}
+
+if (require.main === module) {
+    runCli(process.argv.slice(2)).catch(function (err) {
+        console.error('ucx 执行失败:', err.message);
+        process.exit(1);
+    });
+}
+
+module.exports = runCli;

package/lib/ai_utils.js

@@ -51,13 +51,15 @@ async function fetchRemoteText(url, timeoutMs) {
 
 /**
  * 从当前入口文件名推断正在运行的 CLI 命令名
- * @returns {string} jcc、jcx、weds 或空字符串
+ * @returns {string} jcc、jcx、weds、ucx、jgrok 或空字符串
  */
 function getCurrentCliName() {
     var entryName = path.basename(process.argv[1] || '').toLowerCase();
     if (entryName === 'jcx' || entryName === 'jcx.js') return 'jcx';
     if (entryName === 'jcc' || entryName === 'jcc.js') return 'jcc';
     if (entryName === 'weds' || entryName === 'weds.js') return 'weds';
+    if (entryName === 'ucx' || entryName === 'ucx.js') return 'ucx';
+    if (entryName === 'jgrok' || entryName === 'jgrok.js') return 'jgrok';
     return '';
 }
 

package/lib/jgrok.js

@@ -0,0 +1,202 @@
+'use strict';
+
+/**
+ * jgrok 命令：检测并安装 grok，注入 ~/.grok/.env 后启动官方 grok
+ * 首次创建 .env 只提示编辑，不启动 grok
+ */
+
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var childProcess = require('child_process');
+
+/** ~/.grok/.env 自定义代理示例内容 */
+var GROK_ENV_DEMO = [
+    'HTTP_PROXY=http://127.0.0.1:11811',
+    'HTTPS_PROXY=http://127.0.0.1:11811',
+    'ALL_PROXY=http://127.0.0.1:11811',
+    'NO_PROXY=localhost,127.0.0.1,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16',
+    '',
+].join('\n');
+
+/** 缺失 grok 时走腾讯云 npm 源安装，不加 --force，安装时不注入环境变量 */
+var GROK_INSTALL_CMD = 'npm install -g @xai-official/grok --registry=https://mirrors.cloud.tencent.com/npm/';
+
+/**
+ * 解析用户主目录：优先 buildCfg.homeDir，再 JCC_TEST_HOME，最后 os.homedir()
+ * @param {object} [buildCfg] 入口传入的配置
+ * @returns {string}
+ */
+function getHomeDir(buildCfg) {
+    if (buildCfg && buildCfg.homeDir) {
+        return buildCfg.homeDir;
+    }
+    return process.env.JCC_TEST_HOME || os.homedir();
+}
+
+/**
+ * 获取 ~/.grok 目录路径
+ * @param {string} homeDir 用户主目录
+ * @returns {string}
+ */
+function getGrokDir(homeDir) {
+    return path.join(homeDir, '.grok');
+}
+
+/**
+ * 获取 ~/.grok/.env 绝对路径
+ * @param {string} homeDir 用户主目录
+ * @returns {string}
+ */
+function getGrokEnvPath(homeDir) {
+    return path.join(getGrokDir(homeDir), '.env');
+}
+
+/**
+ * 解析 KEY=VALUE 文本，跳过空行和 # 注释，去掉值两端成对引号
+ * @param {string} content .env 文件内容
+ * @returns {object}
+ */
+function parseEnvFile(content) {
+    var env = {};
+    String(content || '').replace(/^\uFEFF/, '').split(/\r?\n/).forEach(function (line) {
+        var trimmed = line.trim();
+        if (!trimmed || trimmed.charAt(0) === '#') {
+            return;
+        }
+        var eq = trimmed.indexOf('=');
+        if (eq <= 0) {
+            return;
+        }
+        var key = trimmed.slice(0, eq).trim();
+        var value = trimmed.slice(eq + 1).trim();
+        var quote = value.charAt(0);
+        if ((quote === '"' || quote === "'") && value.length >= 2 && value.charAt(value.length - 1) === quote) {
+            value = value.slice(1, -1);
+        }
+        env[key] = value;
+    });
+    return env;
+}
+
+/**
+ * 检测本机是否存在指定命令：Windows 用 where，其它用 which
+ * @param {string} name 命令名
+ * @param {object} [options] 可选配置，execImpl 用于注入 execSync
+ * @returns {boolean}
+ */
+function commandExists(name, options) {
+    options = options || {};
+    var exec = options.execImpl || childProcess.execSync;
+    var cmd = process.platform === 'win32' ? ('where ' + name) : ('which ' + name);
+    try {
+        exec(cmd, { stdio: 'ignore' });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * 本机没有 grok 时通过腾讯云 npm 源全局安装，安装失败向上抛错
+ * 安装不注入 ~/.grok/.env，直接走镜像源
+ * @param {object} [options] 可选配置，execImpl 用于注入 execSync
+ * @returns {void}
+ */
+function ensureGrokInstalled(options) {
+    if (commandExists('grok', options)) {
+        return;
+    }
+    options = options || {};
+    var exec = options.execImpl || childProcess.execSync;
+    console.log('未检测到 grok，正在从腾讯云 npm 源安装 @xai-official/grok ...');
+    exec(GROK_INSTALL_CMD, { stdio: 'inherit' });
+}
+
+/**
+ * 确保 ~/.grok/.env 存在；不存在则写入代理示例，已存在则不覆盖
+ * @param {string} homeDir 用户主目录
+ * @returns {{ created: boolean, envPath: string }}
+ */
+function ensureGrokEnvFile(homeDir) {
+    var grokDir = getGrokDir(homeDir);
+    var envPath = getGrokEnvPath(homeDir);
+    if (!fs.existsSync(grokDir)) {
+        fs.mkdirSync(grokDir, { recursive: true });
+    }
+    if (fs.existsSync(envPath)) {
+        return { created: false, envPath: envPath };
+    }
+    fs.writeFileSync(envPath, GROK_ENV_DEMO, 'utf8');
+    return { created: true, envPath: envPath };
+}
+
+/**
+ * 将 .env 解析结果覆盖到当前进程环境副本上，供子进程使用
+ * @param {string} content .env 文件内容
+ * @returns {object}
+ */
+function buildChildEnv(content) {
+    return Object.assign({}, process.env, parseEnvFile(content));
+}
+
+/**
+ * 启动官方 grok，Windows 走 shell 以便找到 grok.cmd
+ * @param {Array<string>} args 透传给 grok 的参数
+ * @param {object} childEnv 注入后的环境变量
+ * @param {object} [options] 可选配置，spawnImpl 用于注入 spawnSync
+ * @returns {number} grok 退出码
+ */
+function spawnGrok(args, childEnv, options) {
+    options = options || {};
+    var spawn = options.spawnImpl || childProcess.spawnSync;
+    var result = spawn('grok', args || [], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+        env: childEnv,
+    }) || {};
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.signal) {
+        return 1;
+    }
+    return typeof result.status === 'number' ? result.status : 0;
+}
+
+/**
+ * 执行 jgrok：先处理 .env，首次创建则提示编辑；否则注入环境后安装并启动 grok
+ * @param {Array<string>} args 透传给 grok 的参数
+ * @param {object} buildCfg 含 homeDir 的配置
+ * @param {object} [options] 可选配置，execImpl/spawnImpl 用于单测注入
+ * @returns {Promise<number>} 退出码
+ */
+async function runJgrok(args, buildCfg, options) {
+    options = options || {};
+    var homeDir = getHomeDir(buildCfg);
+    var envResult = ensureGrokEnvFile(homeDir);
+    if (envResult.created) {
+        console.log('已首次创建 grok 环境文件，请编辑后再运行 jgrok：');
+        console.log(envResult.envPath);
+        return 0;
+    }
+    var childEnv = buildChildEnv(fs.readFileSync(envResult.envPath, 'utf8'));
+    ensureGrokInstalled(options);
+    return spawnGrok(args || [], childEnv, options);
+}
+
+runJgrok._private = {
+    GROK_ENV_DEMO: GROK_ENV_DEMO,
+    GROK_INSTALL_CMD: GROK_INSTALL_CMD,
+    getHomeDir: getHomeDir,
+    getGrokDir: getGrokDir,
+    getGrokEnvPath: getGrokEnvPath,
+    parseEnvFile: parseEnvFile,
+    commandExists: commandExists,
+    ensureGrokInstalled: ensureGrokInstalled,
+    ensureGrokEnvFile: ensureGrokEnvFile,
+    buildChildEnv: buildChildEnv,
+    spawnGrok: spawnGrok,
+};
+
+module.exports = runJgrok;

package/lib/project_md_rename.js

@@ -0,0 +1,195 @@
+'use strict';
+
+/**
+ * 项目目录中 AGENTS.md 与 CLAUDE.md 的互转重命名
+ * 扫描范围：当前执行目录及其一层子目录，不递归、不覆盖、不跟随符号链接
+ */
+
+var fs = require('fs');
+var path = require('path');
+var inquirer = require('inquirer');
+
+// 菜单哨兵值，避免与服务端渠道 id 冲突。
+var RENAME_AGENTS_TO_CLAUDE = '__rename_agents_to_claude__';
+var RENAME_CLAUDE_TO_AGENTS = '__rename_claude_to_agents__';
+var AGENTS_MD = 'AGENTS.md';
+var CLAUDE_MD = 'CLAUDE.md';
+
+/**
+ * 判断渠道列表选中值是否为项目 md 重命名项
+ * @param {string} channelId 菜单选中值
+ * @returns {boolean}
+ */
+function isRenameChoice(channelId) {
+    return channelId === RENAME_AGENTS_TO_CLAUDE || channelId === RENAME_CLAUDE_TO_AGENTS;
+}
+
+/**
+ * 生成重命名确认文案
+ * @param {string} fromName 源文件名
+ * @param {string} toName 目标文件名
+ * @returns {string}
+ */
+function confirmRenameMessage(fromName, toName) {
+    return '确认将当前目录及一层子目录中的 ' + fromName + ' 重命名为 ' + toName + ' 吗？';
+}
+
+/**
+ * 按方向返回单条重命名菜单项：jcc 仅 AGENTS→CLAUDE，jcx 仅 CLAUDE→AGENTS
+ * @param {string} renameValue 重命名哨兵值
+ * @returns {{name: string, value: string}|null}
+ */
+function getRenameChoice(renameValue) {
+    if (renameValue === RENAME_AGENTS_TO_CLAUDE) {
+        return {
+            name: 'AGENTS.md 转 CLAUDE.md  — 重命名当前目录及一层子目录中的文件',
+            value: RENAME_AGENTS_TO_CLAUDE,
+        };
+    }
+    if (renameValue === RENAME_CLAUDE_TO_AGENTS) {
+        return {
+            name: 'CLAUDE.md 转 AGENTS.md  — 重命名当前目录及一层子目录中的文件',
+            value: RENAME_CLAUDE_TO_AGENTS,
+        };
+    }
+    return null;
+}
+
+/**
+ * 在清除项之前追加对应方向的一条重命名入口
+ * @param {Array<object>} choices inquirer 选项数组
+ * @param {string} renameValue 重命名哨兵值
+ * @returns {Array<object>}
+ */
+function appendRenameChoice(choices, renameValue) {
+    var item = getRenameChoice(renameValue);
+    if (item) {
+        choices.push(item);
+    }
+    return choices;
+}
+
+/**
+ * 列出需要扫描的目录：root 本身 + 一层非隐藏、非符号链接子目录
+ * @param {string} rootDir 项目根目录
+ * @returns {string[]}
+ */
+function listScanDirs(rootDir) {
+    var root = path.resolve(rootDir);
+    var dirs = [root];
+    var entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    } catch (e) {
+        console.warn('⚠️  读取目录失败（' + root + '）: ' + e.message);
+        return dirs;
+    }
+    entries.forEach(function (dirent) {
+        // 跳过点开头目录，避免改到 .git / .claude / .codex
+        if (dirent.name.charAt(0) === '.') {
+            return;
+        }
+        // 不跟随符号链接，只用 Dirent 自身类型判断
+        if (typeof dirent.isSymbolicLink === 'function' && dirent.isSymbolicLink()) {
+            return;
+        }
+        if (!dirent.isDirectory()) {
+            return;
+        }
+        dirs.push(path.join(root, dirent.name));
+    });
+    return dirs;
+}
+
+/**
+ * 将 root 及一层子目录中的 fromName 重命名为 toName，目标已存在则跳过
+ * @param {string} rootDir 项目根目录
+ * @param {string} fromName 源文件名
+ * @param {string} toName 目标文件名
+ * @returns {{renamed: number, skippedExisting: number, skippedMissing: number, errors: number}}
+ */
+function renameProjectMdFiles(rootDir, fromName, toName) {
+    var root = path.resolve(rootDir);
+    var dirs = listScanDirs(root);
+    var result = {
+        renamed: 0,
+        skippedExisting: 0,
+        skippedMissing: 0,
+        errors: 0,
+    };
+
+    dirs.forEach(function (dir) {
+        var fromPath = path.join(dir, fromName);
+        var toPath = path.join(dir, toName);
+        try {
+            if (!fs.existsSync(fromPath) || !fs.statSync(fromPath).isFile()) {
+                result.skippedMissing += 1;
+                return;
+            }
+            // 目标已存在则不覆盖，Windows 大小写不敏感时 claude.md 也会命中
+            if (fs.existsSync(toPath)) {
+                console.warn('⚠️  跳过（目标已存在）: ' + toPath);
+                result.skippedExisting += 1;
+                return;
+            }
+            fs.renameSync(fromPath, toPath);
+            var relative = path.relative(root, dir);
+            var displayDir = relative || '.';
+            console.log(fromName + ' -> ' + toName + ' (' + displayDir + ')');
+            result.renamed += 1;
+        } catch (e) {
+            console.warn('⚠️  重命名失败（' + fromPath + '）: ' + e.message);
+            result.errors += 1;
+        }
+    });
+
+    if (result.renamed === 0) {
+        if (result.skippedExisting > 0) {
+            console.log('未执行重命名：目标文件已存在。');
+        } else {
+            console.log('未找到可重命名的 ' + fromName + '。');
+        }
+    } else {
+        console.log('✅ 已重命名 ' + result.renamed + ' 个文件: ' + fromName + ' -> ' + toName);
+    }
+    return result;
+}
+
+/**
+ * 处理项目 md 重命名菜单项：确认后按 cwd 及一层子目录改名
+ * @param {string} channelId 菜单选中值
+ * @returns {Promise<boolean>} 是否已作为重命名项处理（含用户取消）
+ */
+async function handleRenameChoice(channelId) {
+    if (!isRenameChoice(channelId)) {
+        return false;
+    }
+    var fromName = channelId === RENAME_AGENTS_TO_CLAUDE ? AGENTS_MD : CLAUDE_MD;
+    var toName = channelId === RENAME_AGENTS_TO_CLAUDE ? CLAUDE_MD : AGENTS_MD;
+    var answer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: confirmRenameMessage(fromName, toName),
+        default: false,
+    }]);
+    if (!answer.confirmed) {
+        console.log('已取消重命名。');
+        return true;
+    }
+    renameProjectMdFiles(process.cwd(), fromName, toName);
+    return true;
+}
+
+module.exports = {
+    RENAME_AGENTS_TO_CLAUDE: RENAME_AGENTS_TO_CLAUDE,
+    RENAME_CLAUDE_TO_AGENTS: RENAME_CLAUDE_TO_AGENTS,
+    AGENTS_MD: AGENTS_MD,
+    CLAUDE_MD: CLAUDE_MD,
+    isRenameChoice: isRenameChoice,
+    confirmRenameMessage: confirmRenameMessage,
+    getRenameChoice: getRenameChoice,
+    appendRenameChoice: appendRenameChoice,
+    listScanDirs: listScanDirs,
+    renameProjectMdFiles: renameProjectMdFiles,
+    handleRenameChoice: handleRenameChoice,
+};

package/lib/setapi_cc.js

@@ -12,6 +12,7 @@ var inquirer = require('inquirer');
 var fs = require('fs');
 var utils = require('./ai_utils');
 var childProcess = require('child_process');
+var projectMdRename = require('./project_md_rename');
 
 // Claude 配置清除选项使用固定内部值，避免与服务端渠道 id 冲突。
 var CLEAR_CLAUDE_CONFIG = '__clear_claude_config__';
@@ -84,7 +85,8 @@ async function setapiCc(cmd, buildCfg) {
             value: c.id,
         };
     });
-    // 清除入口固定放在渠道列表最后，即使服务端渠道为空也可恢复官方配置。
+    // jcc/weds 只提供 AGENTS→CLAUDE；清除入口固定最后，即使服务端渠道为空也可恢复官方配置。
+    projectMdRename.appendRenameChoice(choices, projectMdRename.RENAME_AGENTS_TO_CLAUDE);
     choices.push({
         name: '>>>>清除Claude配置<<<<  — 删除并恢复官方默认配置',
         value: CLEAR_CLAUDE_CONFIG,
@@ -100,6 +102,11 @@ async function setapiCc(cmd, buildCfg) {
     }]);
     var channelId = answers.channelId;
 
+    // 项目 md 重命名不写渠道配置，必须在空渠道校验之前处理。
+    if (await projectMdRename.handleRenameChoice(channelId)) {
+        return;
+    }
+
     if (channelId === CLEAR_CLAUDE_CONFIG) {
         var clearAnswer = await inquirer.prompt([{
             type: 'confirm',
@@ -276,6 +283,8 @@ setapiCc._private = {
     validateRequiredInput: validateRequiredInput,
     clearClaudeConfig: clearClaudeConfig,
     CLEAR_CLAUDE_CONFIG: CLEAR_CLAUDE_CONFIG,
+    RENAME_AGENTS_TO_CLAUDE: projectMdRename.RENAME_AGENTS_TO_CLAUDE,
+    RENAME_CLAUDE_TO_AGENTS: projectMdRename.RENAME_CLAUDE_TO_AGENTS,
 };
 
 module.exports = setapiCc;

package/lib/setapi_cx.js

@@ -11,6 +11,7 @@ var inquirer = require('inquirer');
 var utils = require('./ai_utils');
 var childProcess = require('child_process');
 var TOML = require('@ltd/j-toml');
+var projectMdRename = require('./project_md_rename');
 
 // Codex 配置清除选项使用固定内部值，避免与服务端渠道 id 冲突。
 var CLEAR_CODEX_CONFIG = '__clear_codex_config__';
@@ -444,7 +445,8 @@ async function setapiCx(cmd, buildCfg) {
             value: c.id,
         };
     });
-    // 清除入口固定放在渠道列表最后，即使服务端渠道为空也可恢复官方配置。
+    // jcx 只提供 CLAUDE→AGENTS；清除入口固定最后，即使服务端渠道为空也可恢复官方配置。
+    projectMdRename.appendRenameChoice(choices, projectMdRename.RENAME_CLAUDE_TO_AGENTS);
     choices.push({
         name: '>>>>清除Codex配置<<<<  — 删除并恢复官方默认配置',
         value: CLEAR_CODEX_CONFIG,
@@ -457,6 +459,11 @@ async function setapiCx(cmd, buildCfg) {
         choices: choices,
         default: getCurrentCodexChannelId(auth, toml) || undefined,
     }]);
+    // 项目 md 重命名不写渠道配置，必须在空渠道校验之前处理。
+    if (await projectMdRename.handleRenameChoice(answers.channelId)) {
+        return;
+    }
+
     if (answers.channelId === CLEAR_CODEX_CONFIG) {
         var clearAnswer = await inquirer.prompt([{
             type: 'confirm',
@@ -555,6 +562,8 @@ setapiCx._private = {
     validateRequiredInput: validateRequiredInput,
     clearCodexConfig: clearCodexConfig,
     CLEAR_CODEX_CONFIG: CLEAR_CODEX_CONFIG,
+    RENAME_AGENTS_TO_CLAUDE: projectMdRename.RENAME_AGENTS_TO_CLAUDE,
+    RENAME_CLAUDE_TO_AGENTS: projectMdRename.RENAME_CLAUDE_TO_AGENTS,
 };
 
 module.exports = setapiCx;

package/lib/ucx.js

@@ -0,0 +1,562 @@
+'use strict';
+
+/**
+ * ucx 命令：通过重命名 ~/.codex 与 ~/.codex_<账号名> 切换 Codex 账号
+ * 账号名优先用非空 OPENAI_API_KEY 的脱敏短名，否则用 JWT email
+ * 不创建空的 ~/.codex，避免把空目录当成当前账号
+ */
+
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var childProcess = require('child_process');
+var inquirer = require('inquirer');
+var utils = require('./ai_utils');
+
+/** 无法解析账号名时的展示名 */
+var UNKNOWN_EMAIL_LABEL = '未知邮箱';
+
+/** 列表末尾固定项：移除当前账号，以便登录下一个账号 */
+var REMOVE_CURRENT_ACCOUNT = '__remove_current_codex__';
+
+/** ~/.codex/.env 自定义代理示例内容 */
+var CODEX_ENV_DEMO = [
+    'HTTP_PROXY=http://127.0.0.1:11811',
+    'HTTPS_PROXY=http://127.0.0.1:11811',
+    'ALL_PROXY=http://127.0.0.1:11811',
+    'NO_PROXY=localhost,127.0.0.1,10.0.0.0/8,172.16.0.0/12,192.168.0.0/16',
+    '',
+].join('\n');
+
+/**
+ * 解析用户主目录：优先 buildCfg.homeDir，再 JCC_TEST_HOME，最后 os.homedir()
+ * @param {object} [buildCfg] 入口传入的配置
+ * @returns {string}
+ */
+function getHomeDir(buildCfg) {
+    if (buildCfg && buildCfg.homeDir) {
+        return buildCfg.homeDir;
+    }
+    return process.env.JCC_TEST_HOME || os.homedir();
+}
+
+/**
+ * 判断目录名是否为 Codex 账号目录（仅 .codex 或 .codex_*）
+ * @param {string} name 目录名
+ * @returns {boolean}
+ */
+function isCodexAccountDirName(name) {
+    return name === '.codex' || name.indexOf('.codex_') === 0;
+}
+
+/**
+ * 将账号名中 Windows 非法文件名字符替换为下划线，保留 @.+-
+ * @param {string} accountName 邮箱或脱敏 Key 短名
+ * @returns {string}
+ */
+function sanitizeEmailForDir(accountName) {
+    return String(accountName || '').replace(/[<>:"/\\|?*]/g, '_');
+}
+
+/**
+ * 解码 JWT 第二段 payload，不校验签名
+ * @param {string} token JWT 字符串
+ * @returns {object|null}
+ */
+function decodeJwtPayload(token) {
+    if (typeof token !== 'string' || !token) {
+        return null;
+    }
+    var parts = token.split('.');
+    if (parts.length < 2 || !parts[1]) {
+        return null;
+    }
+    try {
+        var json = Buffer.from(parts[1], 'base64url').toString('utf8');
+        return JSON.parse(json);
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * 从 payload 中取出非空 email
+ * @param {object|null} payload JWT payload
+ * @returns {string}
+ */
+function emailFromPayload(payload) {
+    if (!payload || typeof payload.email !== 'string') {
+        return '';
+    }
+    return payload.email;
+}
+
+/**
+ * 从 tokens 字段提取 email：兼容 JWT 字符串、id_token、access_token
+ * @param {*} tokens auth.json 的 tokens 字段
+ * @returns {string}
+ */
+function extractEmailFromTokens(tokens) {
+    if (typeof tokens === 'string') {
+        return emailFromPayload(decodeJwtPayload(tokens));
+    }
+    if (!tokens || typeof tokens !== 'object') {
+        return '';
+    }
+    var fromId = emailFromPayload(decodeJwtPayload(tokens.id_token));
+    if (fromId) {
+        return fromId;
+    }
+    return emailFromPayload(decodeJwtPayload(tokens.access_token));
+}
+
+/**
+ * 读取 auth.json 中的非空 OPENAI_API_KEY
+ * @param {object|null} auth auth.json 对象
+ * @returns {string}
+ */
+function getOpenAiApiKey(auth) {
+    if (!auth || typeof auth.OPENAI_API_KEY !== 'string') {
+        return '';
+    }
+    return auth.OPENAI_API_KEY.trim();
+}
+
+/**
+ * 读取账号目录的展示/停放名：非空 OPENAI_API_KEY 优先用脱敏短名，否则用 JWT email
+ * @param {string} authJsonPath auth.json 路径
+ * @returns {string}
+ */
+function readAccountName(authJsonPath) {
+    var auth = utils.readJsonFile(authJsonPath, null);
+    if (!auth) {
+        return '';
+    }
+    var apiKey = getOpenAiApiKey(auth);
+    if (apiKey) {
+        return utils.maskKey(apiKey);
+    }
+    return extractEmailFromTokens(auth.tokens);
+}
+
+/**
+ * 读取账号目录 auth.json 中的账号名（兼容旧测试名）
+ * @param {string} authJsonPath auth.json 路径
+ * @returns {string}
+ */
+function readAccountEmail(authJsonPath) {
+    return readAccountName(authJsonPath);
+}
+
+/**
+ * 扫描用户主目录一层的 .codex 与 .codex_* 目录，不递归
+ * @param {string} homeDir 用户主目录
+ * @returns {Array<string>} 目录名列表
+ */
+function listCodexAccountDirs(homeDir) {
+    var entries;
+    try {
+        entries = fs.readdirSync(homeDir, { withFileTypes: true });
+    } catch (e) {
+        return [];
+    }
+    var names = [];
+    entries.forEach(function (ent) {
+        if (!ent.isDirectory()) {
+            return;
+        }
+        if (isCodexAccountDirName(ent.name)) {
+            names.push(ent.name);
+        }
+    });
+    return names;
+}
+
+/**
+ * 把账号目录转成统一记录
+ * @param {string} homeDir 用户主目录
+ * @param {string} dirName 目录名
+ * @returns {object}
+ */
+function buildAccountRecord(homeDir, dirName) {
+    var dirPath = path.join(homeDir, dirName);
+    var accountName = readAccountName(path.join(dirPath, 'auth.json'));
+    var parkedName = accountName ? ('.codex_' + sanitizeEmailForDir(accountName)) : '';
+    return {
+        dirName: dirName,
+        dirPath: dirPath,
+        accountName: accountName,
+        email: accountName,
+        displayEmail: accountName || UNKNOWN_EMAIL_LABEL,
+        parkedName: parkedName,
+        isCurrent: dirName === '.codex',
+    };
+}
+
+/**
+ * 读取全部 Codex 账号记录，当前账号置顶
+ * @param {string} homeDir 用户主目录
+ * @returns {Array<object>}
+ */
+function buildAccountRecords(homeDir) {
+    var records = listCodexAccountDirs(homeDir).map(function (dirName) {
+        return buildAccountRecord(homeDir, dirName);
+    });
+    records.sort(function (a, b) {
+        if (a.isCurrent !== b.isCurrent) {
+            return a.isCurrent ? -1 : 1;
+        }
+        var emailCmp = String(a.displayEmail).localeCompare(String(b.displayEmail));
+        if (emailCmp !== 0) {
+            return emailCmp;
+        }
+        return String(a.dirName).localeCompare(String(b.dirName));
+    });
+    return records;
+}
+
+/**
+ * 生成 inquirer 账号列表项，value 使用 dirPath 保证唯一
+ * @param {Array<object>} records 账号记录
+ * @returns {Array<{name: string, value: string}>}
+ */
+function buildAccountChoices(records) {
+    return records.map(function (record) {
+        var suffix = '  (~/' + record.dirName + ')';
+        var name = record.displayEmail + suffix;
+        if (record.isCurrent) {
+            name += '  当前';
+        }
+        return { name: name, value: record.dirPath };
+    });
+}
+
+/**
+ * 生成完整选项：账号列表末尾固定追加「移除当前账号」，无账号时也要显示
+ * @param {Array<object>} records 账号记录
+ * @returns {Array<{name: string, value: string}>}
+ */
+function buildUcxChoices(records) {
+    var choices = buildAccountChoices(records);
+    choices.push({
+        name: '*移除当前账号*',
+        value: REMOVE_CURRENT_ACCOUNT,
+    });
+    return choices;
+}
+
+/**
+ * 写入 ~/.codex/.env 代理示例；目录不存在时先创建
+ * @param {string} homeDir 用户主目录
+ * @returns {string} 写入的 .env 路径
+ */
+function writeCodexEnvDemo(homeDir) {
+    var codexDir = path.join(homeDir, '.codex');
+    if (!fs.existsSync(codexDir)) {
+        fs.mkdirSync(codexDir, { recursive: true });
+    }
+    var envPath = path.join(codexDir, '.env');
+    fs.writeFileSync(envPath, CODEX_ENV_DEMO, 'utf8');
+    return envPath;
+}
+
+/**
+ * 询问是否新建 ~/.codex/.env 用于自定义代理
+ * @param {string} homeDir 用户主目录
+ * @returns {Promise<boolean>} 是否已写入
+ */
+async function maybeCreateCodexEnv(homeDir) {
+    var envAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: '是否新建 ~/.codex/.env 用于自定义代理？',
+        default: false,
+    }]);
+    if (!envAnswer.confirmed) {
+        return false;
+    }
+    var envPath = writeCodexEnvDemo(homeDir);
+    console.log('已写入 ' + envPath);
+    return true;
+}
+
+/**
+ * 移除当前账号：有登录信息则停放改名；三无目录与切换时相同，询问删除或手工命名
+ * @param {string} homeDir 用户主目录
+ * @param {object|null} currentRecord 当前 ~/.codex 记录
+ * @param {object} [options] 可选配置，execImpl 用于注入杀进程实现
+ * @returns {Promise<{ cancelled: boolean }>}
+ */
+async function removeCurrentAccount(homeDir, currentRecord, options) {
+    options = options || {};
+    var confirmAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: '确认移除当前账号，以便登录新账号吗？',
+        default: false,
+    }]);
+    if (!confirmAnswer.confirmed) {
+        console.log('已取消移除当前账号。');
+        return { cancelled: true };
+    }
+
+    var currentPath = path.join(homeDir, '.codex');
+    var unnamedAction = null;
+    if (fs.existsSync(currentPath) && !(currentRecord && currentRecord.accountName)) {
+        unnamedAction = await promptUnnamedCurrentAction();
+    }
+
+    killCodexProcesses(options.execImpl);
+    if (!fs.existsSync(currentPath)) {
+        console.log('当前没有 ~/.codex 目录。');
+    } else if (unnamedAction) {
+        applyUnnamedCurrentAction(homeDir, currentPath, unnamedAction);
+    } else {
+        var parkedName = allocateParkedDirName(homeDir, currentRecord.accountName);
+        var parkedPath = path.join(homeDir, parkedName);
+        fs.renameSync(currentPath, parkedPath);
+        console.log('已移除当前账号，已停放到 ' + parkedPath);
+    }
+
+    await maybeCreateCodexEnv(homeDir);
+    return { cancelled: false };
+}
+
+/**
+ * 终止本机 Codex 进程；测试环境或注入 exec 时避免误杀宿主机进程
+ * @param {Function} [execImpl] 可注入的 execSync，便于单测
+ * @returns {void}
+ */
+function killCodexProcesses(execImpl) {
+    if (process.env.JCC_TEST_HOME) {
+        return;
+    }
+    var exec = execImpl || childProcess.execSync;
+    var commands = process.platform === 'win32'
+        ? ['taskkill /F /IM codex.exe', 'taskkill /F /IM codex']
+        : ['pkill -x codex'];
+    commands.forEach(function (cmd) {
+        try {
+            exec(cmd, { stdio: 'ignore' });
+        } catch (e) {
+            // 无匹配进程时 taskkill/pkill 常返回非 0，忽略
+        }
+    });
+}
+
+/**
+ * 为当前账号分配不冲突的停放目录名；同名已存在时追加 _2、_3，不覆盖
+ * @param {string} homeDir 用户主目录
+ * @param {string} accountName 邮箱或脱敏 Key 短名
+ * @returns {string} 可用的目录名，例如 .codex_a 或 .codex_a_2
+ */
+function allocateParkedDirName(homeDir, accountName) {
+    var base = '.codex_' + sanitizeEmailForDir(accountName);
+    var name = base;
+    var index = 2;
+    while (fs.existsSync(path.join(homeDir, name))) {
+        name = base + '_' + index;
+        index += 1;
+    }
+    return name;
+}
+
+/**
+ * 校验用户输入的停放目录名，只用于改名，不写回 auth.json
+ * @param {string} value 用户输入
+ * @returns {boolean|string}
+ */
+function validateParkName(value) {
+    var trimmed = String(value || '').trim();
+    if (!trimmed) {
+        return '名称不能为空';
+    }
+    if (!sanitizeEmailForDir(trimmed)) {
+        return '名称包含无效字符';
+    }
+    return true;
+}
+
+/**
+ * 三无当前目录：询问是否删除，否则让用户输入停放名（不写回 auth.json）
+ * @returns {Promise<{ deleteCurrent: boolean, parkName?: string }>}
+ */
+async function promptUnnamedCurrentAction() {
+    var deleteAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: '当前目录没有登陆账号，是否删除？',
+        default: false,
+    }]);
+    if (deleteAnswer.confirmed) {
+        return { deleteCurrent: true };
+    }
+    var nameAnswer = await inquirer.prompt([{
+        type: 'input',
+        name: 'accountName',
+        message: '请输入用于停放当前目录的名称（不会写回 auth.json）',
+        validate: validateParkName,
+    }]);
+    return { deleteCurrent: false, parkName: String(nameAnswer.accountName || '').trim() };
+}
+
+/**
+ * 按三无目录的用户选择删除或手工命名停放，名称不写回 auth.json
+ * @param {string} homeDir 用户主目录
+ * @param {string} currentPath 当前 ~/.codex 路径
+ * @param {{ deleteCurrent: boolean, parkName?: string }} action 用户选择
+ * @returns {string|null} 停放后的路径，删除时为 null
+ */
+function applyUnnamedCurrentAction(homeDir, currentPath, action) {
+    if (action.deleteCurrent) {
+        fs.rmSync(currentPath, { recursive: true, force: true });
+        console.log('已删除空的 ~/.codex 目录。');
+        return null;
+    }
+    var parkedName = allocateParkedDirName(homeDir, action.parkName);
+    var parkedPath = path.join(homeDir, parkedName);
+    fs.renameSync(currentPath, parkedPath);
+    console.log('已将当前目录停放到 ' + parkedPath);
+    return parkedPath;
+}
+
+/**
+ * 校验当前 ~/.codex 是否具备可停放的账号名
+ * @param {object|null} currentRecord 当前账号记录，没有当前目录时为 null
+ * @returns {void}
+ */
+function assertCanParkCurrent(homeDir, currentRecord) {
+    if (!currentRecord) {
+        return;
+    }
+    if (!currentRecord.accountName) {
+        throw new Error('当前 .codex 无法解析账号名，拒绝停放以免丢失账号目录');
+    }
+}
+
+/**
+ * 执行账号目录切换：停放当前 .codex，再把选中目录改名为 .codex
+ * 当前为三无目录时先询问删除或手工命名，名称不写回 auth.json
+ * @param {string} homeDir 用户主目录
+ * @param {object} selected 选中的账号记录
+ * @param {Array<object>} records 全部账号记录
+ * @param {object} [options] 可选配置，execImpl 用于注入杀进程实现
+ * @returns {Promise<{ skipped: boolean, email?: string }>}
+ */
+async function switchCodexAccount(homeDir, selected, records, options) {
+    options = options || {};
+    if (!selected) {
+        throw new Error('未找到要切换的 Codex 账号');
+    }
+    if (selected.isCurrent) {
+        console.log('当前已是 ' + selected.displayEmail + '，无需切换');
+        return { skipped: true };
+    }
+
+    var currentRecord = null;
+    records.forEach(function (record) {
+        if (record.isCurrent) {
+            currentRecord = record;
+        }
+    });
+
+    var unnamedAction = null;
+    if (currentRecord && !currentRecord.accountName) {
+        unnamedAction = await promptUnnamedCurrentAction();
+    } else {
+        assertCanParkCurrent(homeDir, currentRecord);
+    }
+
+    killCodexProcesses(options.execImpl);
+
+    var parkedPath = null;
+    if (currentRecord && unnamedAction) {
+        parkedPath = applyUnnamedCurrentAction(homeDir, currentRecord.dirPath, unnamedAction);
+    } else if (currentRecord) {
+        var parkedName = allocateParkedDirName(homeDir, currentRecord.accountName);
+        parkedPath = path.join(homeDir, parkedName);
+        fs.renameSync(currentRecord.dirPath, parkedPath);
+    }
+
+    var targetPath = path.join(homeDir, '.codex');
+    try {
+        fs.renameSync(selected.dirPath, targetPath);
+    } catch (e) {
+        if (parkedPath) {
+            console.error('已将原账号停放到 ' + parkedPath + '，但启用新账号失败，请手动恢复');
+        }
+        throw e;
+    }
+
+    console.log('已切换到 ' + selected.displayEmail + '，请重新启动 Codex');
+    return { skipped: false, email: selected.displayEmail };
+}
+
+/**
+ * 按路径从记录中查找账号
+ * @param {Array<object>} records 账号记录
+ * @param {string} dirPath 目录绝对路径
+ * @returns {object|undefined}
+ */
+function findRecordByDirPath(records, dirPath) {
+    var matched;
+    records.forEach(function (record) {
+        if (record.dirPath === dirPath) {
+            matched = record;
+        }
+    });
+    return matched;
+}
+
+/**
+ * 执行 ucx 交互切换
+ * @param {object} cmd commander 选项（当前无业务字段）
+ * @param {object} buildCfg 含 homeDir 的配置
+ * @returns {Promise<void>}
+ */
+async function runUcx(cmd, buildCfg) {
+    var homeDir = getHomeDir(buildCfg);
+    var records = buildAccountRecords(homeDir);
+    var current = findRecordByDirPath(records, path.join(homeDir, '.codex'));
+    var answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'dirPath',
+        message: '请选择要切换的 Codex 账号',
+        choices: buildUcxChoices(records),
+        default: current ? current.dirPath : undefined,
+    }]);
+
+    if (answer.dirPath === REMOVE_CURRENT_ACCOUNT) {
+        await removeCurrentAccount(homeDir, current || null, {});
+        return;
+    }
+
+    var selected = findRecordByDirPath(records, answer.dirPath);
+    await switchCodexAccount(homeDir, selected, records, {});
+}
+
+runUcx._private = {
+    UNKNOWN_EMAIL_LABEL: UNKNOWN_EMAIL_LABEL,
+    REMOVE_CURRENT_ACCOUNT: REMOVE_CURRENT_ACCOUNT,
+    CODEX_ENV_DEMO: CODEX_ENV_DEMO,
+    getHomeDir: getHomeDir,
+    sanitizeEmailForDir: sanitizeEmailForDir,
+    decodeJwtPayload: decodeJwtPayload,
+    extractEmailFromTokens: extractEmailFromTokens,
+    getOpenAiApiKey: getOpenAiApiKey,
+    readAccountName: readAccountName,
+    readAccountEmail: readAccountEmail,
+    listCodexAccountDirs: listCodexAccountDirs,
+    buildAccountRecords: buildAccountRecords,
+    buildAccountChoices: buildAccountChoices,
+    buildUcxChoices: buildUcxChoices,
+    allocateParkedDirName: allocateParkedDirName,
+    writeCodexEnvDemo: writeCodexEnvDemo,
+    validateParkName: validateParkName,
+    killCodexProcesses: killCodexProcesses,
+    assertCanParkCurrent: assertCanParkCurrent,
+    switchCodexAccount: switchCodexAccount,
+    removeCurrentAccount: removeCurrentAccount,
+};
+
+module.exports = runUcx;

package/main.js

@@ -6,7 +6,7 @@ var path = require('path');
 var inquirer = require('inquirer');
 var packageJson = require('./package.json');
 
-var VALID_TARGETS = ['jcc', 'jcx', 'weds'];
+var VALID_TARGETS = ['jcc', 'jcx', 'weds', 'ucx', 'jgrok'];
 
 /**
  * 打印 base_parts_ai 入口命令的中文帮助信息
@@ -17,10 +17,12 @@ function printUsage() {
         'base_parts_ai 入口工具',
         '',
         '用法:',
-        '  base_parts_ai                 选择 jcc、jcx 或 weds 后继续执行',
+        '  base_parts_ai                 选择 jcc、jcx、weds、ucx 或 jgrok 后继续执行',
         '  base_parts_ai jcc [参数...]   执行 Claude Code 配置工具',
         '  base_parts_ai jcx [参数...]   执行 Codex 配置工具',
         '  base_parts_ai weds [参数...]  执行 weds Claude Code 配置工具',
+        '  base_parts_ai ucx [参数...]   通过目录改名切换 Codex 账号',
+        '  base_parts_ai jgrok [参数...] 注入 ~/.grok/.env 后启动 grok',
         '  base_parts_ai --help          显示入口帮助',
         '  base_parts_ai --version       显示当前版本',
         '',
@@ -56,13 +58,13 @@ function resolveTarget(args) {
 
     return {
         type: 'error',
-        message: '参数无效：有参数时必须先明确指定 jcc、jcx 或 weds。',
+        message: '参数无效：有参数时必须先明确指定 jcc、jcx、weds、ucx 或 jgrok。',
     };
 }
 
 /**
  * 让用户选择要继续执行的配置工具
- * @returns {Promise<string>} jcc、jcx 或 weds
+ * @returns {Promise<string>} jcc、jcx、weds、ucx 或 jgrok
  */
 async function selectTarget() {
     var answer = await inquirer.prompt([{
@@ -73,6 +75,8 @@ async function selectTarget() {
             { name: 'jcc - Claude Code 配置工具', value: 'jcc' },
             { name: 'jcx - Codex 配置工具', value: 'jcx' },
             { name: 'weds - weds Claude Code 配置工具', value: 'weds' },
+            { name: 'ucx - 切换 Codex 账号', value: 'ucx' },
+            { name: 'jgrok - 带代理环境启动 grok', value: 'jgrok' },
         ],
     }]);
     return answer.target;
@@ -80,7 +84,7 @@ async function selectTarget() {
 
 /**
  * 获取当前包内目标 CLI 脚本路径
- * @param {string} target jcc、jcx 或 weds
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @returns {string}
  */
 function getTargetScriptPath(target) {
@@ -88,8 +92,8 @@ function getTargetScriptPath(target) {
 }
 
 /**
- * 加载当前包内的 jcc/jcx/weds 入口函数
- * @param {string} target jcc、jcx 或 weds
+ * 加载当前包内的 jcc/jcx/weds/ucx/jgrok 入口函数
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @returns {Function}
  */
 function loadTargetCli(target) {
@@ -97,8 +101,8 @@ function loadTargetCli(target) {
 }
 
 /**
- * 同进程执行当前包内的 jcc/jcx/weds 入口，并临时注入跳过自身升级的环境变量
- * @param {string} target jcc、jcx 或 weds
+ * 同进程执行当前包内的 jcc/jcx/weds/ucx/jgrok 入口，并临时注入跳过自身升级的环境变量
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @param {Array<string>} args 透传给目标入口的参数
  * @param {Function} loader 测试用入口加载函数，默认 loadTargetCli
  * @returns {Promise<number>} 退出码
@@ -111,8 +115,8 @@ async function runTarget(target, args, loader) {
         if (typeof runCli !== 'function') {
             throw new Error(target + ' 入口没有导出可调用函数');
         }
-        await runCli(args || []);
-        return 0;
+        var result = await runCli(args || []);
+        return typeof result === 'number' ? result : 0;
     } finally {
         if (typeof oldSkipSelfUpdate === 'undefined') {
             delete process.env.BASE_PARTS_AI_SKIP_SELF_UPDATE;

package/package.json

@@ -1,15 +1,17 @@
 {
   "name": "base_parts_ai",
-  "version": "1.0.55",
+  "version": "1.0.57",
   "description": "jaskle base_parts_ai",
   "main": "./main.js",
   "registry": true,
   "directories": {},
   "scripts": {
-    "test": "node ./test_main.js && node ./test_jcc.js && node ./test_jcx.js",
+    "test": "node ./test_project_md_rename.js && node ./test_main.js && node ./test_jcc.js && node ./test_jcx.js && node ./test_ucx.js && node ./test_jgrok.js",
     "jcc": "node ./bin/jcc.js",
     "jcx": "node ./bin/jcx.js",
     "weds": "node ./bin/weds.js",
+    "ucx": "node ./bin/ucx.js",
+    "jgrok": "node ./bin/jgrok.js",
     "base_parts_ai": "node ./main.js",
     "__postinstall": "node ./bin/postinstall.js"
   },
@@ -17,7 +19,9 @@
     "base_parts_ai": "./main.js",
     "jcc": "./bin/jcc.js",
     "jcx": "./bin/jcx.js",
-    "weds": "./bin/weds.js"
+    "weds": "./bin/weds.js",
+    "ucx": "./bin/ucx.js",
+    "jgrok": "./bin/jgrok.js"
   },
   "files": [
     "main.js",