base_parts_ai 1.0.56 → 1.0.58

package/README.md

@@ -7,7 +7,7 @@
 npx base_parts_ai
 ```
 
-无参数时会让用户选择 `jcc`、`jcx`、`weds` 或 `ucx`，再继续执行对应配置流程。
+无参数时会让用户选择 `jcc`、`jcx`、`weds`、`ucx` 或 `jgrok`，再继续执行对应流程。
 
 也可以明确指定工具，适合脚本或需要带参数的场景：
 
@@ -16,6 +16,7 @@ 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
@@ -28,18 +29,21 @@ npx base_parts_ai --help
 npx base_parts_ai --version
 ```
 
-通过 `base_parts_ai` 入口执行时，会屏蔽 `base_parts_ai` 自身自动升级；`jcc`、`jcx`、`weds`、`ucx` 单独运行行为保持不变。
+通过 `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`。
+`ucx` 会扫描用户主目录下一层的 `~/.codex` 与 `~/.codex_*`。账号名由 `config.toml` 顶层 `model_provider`、`auth.json` 中非空 `OPENAI_API_KEY` 的脱敏短名、JWT email 组合成 `配置名_Key_Email`，缺段去掉；不会自动创建空的 `~/.codex`。选中当前 `~/.codex` 会进入二级菜单，只在该目录内用 `juser_*` 切换 `config.toml`、`auth.json`、`.env`、`models.json`，不改其它 `~/.codex_*` 账号目录。
+
+`jgrok` 若 `~/.grok/.env` 不存在则写入代理示例并打印绝对路径，请编辑后再运行。已存在则把该文件注入环境变量：本机没有 `grok` 时通过腾讯云 npm 源安装 `@xai-official/grok`（安装不注入环境变量），然后启动 `grok`，用户参数原样透传。
 
 ## 下载发布的包
-https://registry.npmjs.org/base_parts_ai/-/base_parts_ai-1.0.56.tgz
+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

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

@@ -17,5 +17,6 @@ console.log(c.cyan + '  ║  ' + c.yellow + '安装完成！输入以下命令
 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

@@ -50,7 +50,7 @@ async function runCli(args) {
 
     program
         .name('ucx')
-        .description('通过目录改名切换 Codex 账号')
+        .description('通过目录改名切换 Codex 账号，选中当前目录可切换其子账户')
         .version(packageJson.version)
         .action(async function () {
             await runSwitch();

package/lib/ai_utils.js

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

@@ -2,8 +2,9 @@
 
 /**
  * ucx 命令：通过重命名 ~/.codex 与 ~/.codex_<账号名> 切换 Codex 账号
- * 账号名优先用非空 OPENAI_API_KEY 的脱敏短名，否则用 JWT email
+ * 账号名由配置名、脱敏 Key、JWT email 组合，缺段去掉；配置名来自 config.toml 的 model_provider
  * 不创建空的 ~/.codex，避免把空目录当成当前账号
+ * 选中当前 ~/.codex 进入二级菜单，只在该目录内用 juser_* 切换子账户，不碰 ~/.codex_*
  */
 
 var fs = require('fs');
@@ -11,6 +12,7 @@ var os = require('os');
 var path = require('path');
 var childProcess = require('child_process');
 var inquirer = require('inquirer');
+var TOML = require('@ltd/j-toml');
 var utils = require('./ai_utils');
 
 /** 无法解析账号名时的展示名 */
@@ -19,6 +21,18 @@ var UNKNOWN_EMAIL_LABEL = '未知邮箱';
 /** 列表末尾固定项：移除当前账号，以便登录下一个账号 */
 var REMOVE_CURRENT_ACCOUNT = '__remove_current_codex__';
 
+/** 二级菜单：移除当前子账户（只停放 4 个配置文件） */
+var REMOVE_CURRENT_SUB = '__remove_current_sub__';
+
+/** 二级菜单：返回一级账号列表 */
+var BACK_TO_PARENT = '__back_to_parent__';
+
+/** 子账户目录前缀，只出现在当前 ~/.codex 内 */
+var SUB_DIR_PREFIX = 'juser_';
+
+/** 子账户只交换这 4 个文件，其它文件留在 ~/.codex */
+var SUB_FILE_NAMES = ['config.toml', 'auth.json', '.env', 'models.json'];
+
 /** ~/.codex/.env 自定义代理示例内容 */
 var CODEX_ENV_DEMO = [
     'HTTP_PROXY=http://127.0.0.1:11811',
@@ -51,7 +65,7 @@ function isCodexAccountDirName(name) {
 
 /**
  * 将账号名中 Windows 非法文件名字符替换为下划线，保留 @.+-
- * @param {string} accountName 邮箱或脱敏 Key 短名
+ * @param {string} accountName 组合展示名（配置名_Key_Email）
  * @returns {string}
  */
 function sanitizeEmailForDir(accountName) {
@@ -123,20 +137,69 @@ function getOpenAiApiKey(auth) {
 }
 
 /**
- * 读取账号目录的展示/停放名：非空 OPENAI_API_KEY 优先用脱敏短名，否则用 JWT email
- * @param {string} authJsonPath auth.json 路径
+ * 读取账号目录 config.toml 顶层 model_provider 作为配置名
+ * 文件缺失、解析失败、字段为空或非字符串时返回空串，避免阻断账号列表
+ * @param {string} configTomlPath config.toml 路径
  * @returns {string}
  */
-function readAccountName(authJsonPath) {
-    var auth = utils.readJsonFile(authJsonPath, null);
-    if (!auth) {
+function readModelProvider(configTomlPath) {
+    var text;
+    try {
+        text = fs.readFileSync(configTomlPath, 'utf8');
+    } catch (e) {
         return '';
     }
-    var apiKey = getOpenAiApiKey(auth);
-    if (apiKey) {
-        return utils.maskKey(apiKey);
+    if (!text || !String(text).trim()) {
+        return '';
+    }
+    var config;
+    try {
+        config = TOML.parse(text);
+    } catch (e) {
+        return '';
+    }
+    if (!config || typeof config.model_provider !== 'string') {
+        return '';
+    }
+    return config.model_provider.trim();
+}
+
+/**
+ * 按 配置名_Key_Email 顺序拼接展示名，空段去掉
+ * @param {string} configName config.toml 的 model_provider
+ * @param {string} maskedKey 脱敏后的 OPENAI_API_KEY
+ * @param {string} email JWT 中的邮箱
+ * @returns {string}
+ */
+function composeAccountName(configName, maskedKey, email) {
+    var parts = [];
+    [configName, maskedKey, email].forEach(function (part) {
+        if (part) {
+            parts.push(String(part));
+        }
+    });
+    return parts.join('_');
+}
+
+/**
+ * 读取账号目录的展示/停放名：配置名、脱敏 Key、JWT email 全部读出后组合
+ * @param {string} authJsonPath auth.json 路径，同级目录读取 config.toml
+ * @returns {string}
+ */
+function readAccountName(authJsonPath) {
+    var dirPath = path.dirname(authJsonPath);
+    var configName = readModelProvider(path.join(dirPath, 'config.toml'));
+    var auth = utils.readJsonFile(authJsonPath, null);
+    var maskedKey = '';
+    var email = '';
+    if (auth) {
+        var apiKey = getOpenAiApiKey(auth);
+        if (apiKey) {
+            maskedKey = utils.maskKey(apiKey);
+        }
+        email = extractEmailFromTokens(auth.tokens);
     }
-    return extractEmailFromTokens(auth.tokens);
+    return composeAccountName(configName, maskedKey, email);
 }
 
 /**
@@ -225,7 +288,7 @@ function buildAccountChoices(records) {
         var suffix = '  (~/' + record.dirName + ')';
         var name = record.displayEmail + suffix;
         if (record.isCurrent) {
-            name += '  当前';
+            name += '  当前(点击配置子账号)';
         }
         return { name: name, value: record.dirPath };
     });
@@ -281,7 +344,7 @@ async function maybeCreateCodexEnv(homeDir) {
 }
 
 /**
- * 移除当前账号：有登录信息则停放改名；三无目录与切换时相同，询问删除或手工命名
+ * 移除当前账号：有登录信息则停放改名（不删除）；三无目录与切换时相同，询问删除或手工命名
  * @param {string} homeDir 用户主目录
  * @param {object|null} currentRecord 当前 ~/.codex 记录
  * @param {object} [options] 可选配置，execImpl 用于注入杀进程实现
@@ -292,7 +355,7 @@ async function removeCurrentAccount(homeDir, currentRecord, options) {
     var confirmAnswer = await inquirer.prompt([{
         type: 'confirm',
         name: 'confirmed',
-        message: '确认移除当前账号，以便登录新账号吗？',
+        message: '确认把当前账号从 ~/.codex 停放出来，以便登录新账号吗？（不会删除，会改名为 ~/.codex_xxx）',
         default: false,
     }]);
     if (!confirmAnswer.confirmed) {
@@ -347,7 +410,7 @@ function killCodexProcesses(execImpl) {
 /**
  * 为当前账号分配不冲突的停放目录名；同名已存在时追加 _2、_3，不覆盖
  * @param {string} homeDir 用户主目录
- * @param {string} accountName 邮箱或脱敏 Key 短名
+ * @param {string} accountName 组合展示名（配置名_Key_Email）
  * @returns {string} 可用的目录名，例如 .codex_a 或 .codex_a_2
  */
 function allocateParkedDirName(homeDir, accountName) {
@@ -436,7 +499,7 @@ function assertCanParkCurrent(homeDir, currentRecord) {
 
 /**
  * 执行账号目录切换：停放当前 .codex，再把选中目录改名为 .codex
- * 当前为三无目录时先询问删除或手工命名，名称不写回 auth.json
+ * 当前为三无目录（无配置名、无 Key、无登录信息）时先询问删除或手工命名，名称不写回 auth.json
  * @param {string} homeDir 用户主目录
  * @param {object} selected 选中的账号记录
  * @param {Array<object>} records 全部账号记录
@@ -492,6 +555,406 @@ async function switchCodexAccount(homeDir, selected, records, options) {
     return { skipped: false, email: selected.displayEmail };
 }
 
+/**
+ * 判断目录名是否为当前空间内的子账户目录（仅 juser_*）
+ * @param {string} name 目录名
+ * @returns {boolean}
+ */
+function isSubAccountDirName(name) {
+    return String(name || '').indexOf(SUB_DIR_PREFIX) === 0;
+}
+
+/**
+ * 解析后的路径必须落在当前 ~/.codex 内，防止子账户操作逃到一级账号目录
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {string} targetPath 待检查路径
+ * @returns {string} 解析后的绝对路径
+ */
+function resolvePathInsideCodexDir(codexDir, targetPath) {
+    var root = path.resolve(codexDir);
+    var resolved = path.resolve(targetPath);
+    var prefix = root.endsWith(path.sep) ? root : root + path.sep;
+    if (resolved !== root && resolved.indexOf(prefix) !== 0) {
+        throw new Error('子账户路径必须位于当前 ~/.codex 内');
+    }
+    return resolved;
+}
+
+/**
+ * 扫描当前 ~/.codex 下一层 juser_* 目录，不递归、不看 ~/.codex_*
+ * @param {string} codexDir 当前 ~/.codex
+ * @returns {Array<string>} 目录名列表
+ */
+function listSubAccountDirs(codexDir) {
+    var entries;
+    try {
+        entries = fs.readdirSync(codexDir, { withFileTypes: true });
+    } catch (e) {
+        return [];
+    }
+    var names = [];
+    entries.forEach(function (ent) {
+        if (!ent.isDirectory()) {
+            return;
+        }
+        if (isSubAccountDirName(ent.name)) {
+            names.push(ent.name);
+        }
+    });
+    return names;
+}
+
+/**
+ * 列出目录中实际存在的子账户配置文件
+ * @param {string} dirPath 目录路径
+ * @returns {Array<string>}
+ */
+function listPresentSubFiles(dirPath) {
+    var present = [];
+    SUB_FILE_NAMES.forEach(function (fileName) {
+        var filePath = path.join(dirPath, fileName);
+        try {
+            if (fs.statSync(filePath).isFile()) {
+                present.push(fileName);
+            }
+        } catch (e) {
+            // 文件不存在则跳过，保证缺文件时不会把旧文件留下来
+        }
+    });
+    return present;
+}
+
+/**
+ * 把源目录中存在的 4 个配置文件移动到目标目录；目标已有同名文件则先删
+ * 源和目标都必须在同一个 ~/.codex 内
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {string} srcDir 源目录
+ * @param {string} destDir 目标目录
+ * @returns {void}
+ */
+function moveSubFiles(codexDir, srcDir, destDir) {
+    srcDir = resolvePathInsideCodexDir(codexDir, srcDir);
+    destDir = resolvePathInsideCodexDir(codexDir, destDir);
+    if (!fs.existsSync(destDir)) {
+        fs.mkdirSync(destDir, { recursive: true });
+    }
+    listPresentSubFiles(srcDir).forEach(function (fileName) {
+        var destPath = path.join(destDir, fileName);
+        resolvePathInsideCodexDir(codexDir, destPath);
+        if (fs.existsSync(destPath)) {
+            fs.rmSync(destPath, { force: true });
+        }
+        fs.renameSync(path.join(srcDir, fileName), destPath);
+    });
+}
+
+/**
+ * 删除目录中存在的 4 个配置文件，不删目录本身
+ * @param {string} dirPath 目录路径
+ * @returns {void}
+ */
+function removePresentSubFiles(dirPath) {
+    listPresentSubFiles(dirPath).forEach(function (fileName) {
+        fs.rmSync(path.join(dirPath, fileName), { force: true });
+    });
+}
+
+/**
+ * 子账户目录搬空后删除；还有其它文件则保留，避免把无关内容拷到 ~/.codex 根
+ * @param {string} dirPath 目录路径
+ * @returns {void}
+ */
+function removeDirIfEmpty(dirPath) {
+    var entries;
+    try {
+        entries = fs.readdirSync(dirPath);
+    } catch (e) {
+        return;
+    }
+    if (entries.length === 0) {
+        fs.rmdirSync(dirPath);
+    }
+}
+
+/**
+ * 为当前子账户分配不冲突的 juser_* 目录名，只在 ~/.codex 内查找
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {string} accountName 组合展示名
+ * @returns {string} 目录名，例如 juser_a 或 juser_a_2
+ */
+function allocateParkedSubDirName(codexDir, accountName) {
+    var base = SUB_DIR_PREFIX + sanitizeEmailForDir(accountName);
+    var name = base;
+    var index = 2;
+    while (fs.existsSync(path.join(codexDir, name))) {
+        name = base + '_' + index;
+        index += 1;
+    }
+    return name;
+}
+
+/**
+ * 把当前 ~/.codex 或某个 juser_* 转成子账户记录
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {string} dirName 当前为 .codex，停放为 juser_*
+ * @param {boolean} isCurrent 是否为根上正在生效的 4 个文件
+ * @returns {object}
+ */
+function buildSubAccountRecord(codexDir, dirName, isCurrent) {
+    var dirPath = isCurrent ? codexDir : path.join(codexDir, dirName);
+    var accountName = readAccountName(path.join(dirPath, 'auth.json'));
+    var parkedName = accountName ? (SUB_DIR_PREFIX + sanitizeEmailForDir(accountName)) : '';
+    return {
+        dirName: dirName,
+        dirPath: dirPath,
+        accountName: accountName,
+        displayEmail: accountName || UNKNOWN_EMAIL_LABEL,
+        parkedName: parkedName,
+        isCurrent: !!isCurrent,
+    };
+}
+
+/**
+ * 读取当前空间子账户记录：根上 4 个文件为当前，juser_* 为停放
+ * @param {string} codexDir 当前 ~/.codex
+ * @returns {Array<object>}
+ */
+function buildSubAccountRecords(codexDir) {
+    var records = [buildSubAccountRecord(codexDir, '.codex', true)];
+    listSubAccountDirs(codexDir).forEach(function (dirName) {
+        records.push(buildSubAccountRecord(codexDir, dirName, false));
+    });
+    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;
+}
+
+/**
+ * 生成二级菜单子账户列表项
+ * @param {Array<object>} records 子账户记录
+ * @returns {Array<{name: string, value: string}>}
+ */
+function buildSubAccountChoices(records) {
+    return records.map(function (record) {
+        var suffix = record.isCurrent
+            ? '  (~/.codex)'
+            : '  (~/.codex/' + 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 buildUcxSubChoices(records) {
+    var choices = buildSubAccountChoices(records);
+    choices.push({
+        name: '*移除当前子账户*',
+        value: REMOVE_CURRENT_SUB,
+    });
+    choices.push({
+        name: '*返回上级*',
+        value: BACK_TO_PARENT,
+    });
+    return choices;
+}
+
+/**
+ * 三无当前子账户：询问是否删除这 4 个配置文件，否则手工命名停放到 juser_*
+ * @returns {Promise<{ deleteCurrent: boolean, parkName?: string }>}
+ */
+async function promptUnnamedSubAction() {
+    var deleteAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: '当前没有可识别的子账户配置，是否删除这 4 个配置文件？',
+        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() };
+}
+
+/**
+ * 按三无子账户的选择删除 4 个文件或停放到 ~/.codex/juser_*，不删 ~/.codex
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {{ deleteCurrent: boolean, parkName?: string }} action 用户选择
+ * @returns {string|null} 停放后的路径，删除时为 null
+ */
+function applyUnnamedSubAction(codexDir, action) {
+    if (action.deleteCurrent) {
+        removePresentSubFiles(codexDir);
+        console.log('已删除当前子账户的 4 个配置文件。');
+        return null;
+    }
+    var parkedName = allocateParkedSubDirName(codexDir, action.parkName);
+    var parkedPath = path.join(codexDir, parkedName);
+    moveSubFiles(codexDir, codexDir, parkedPath);
+    console.log('已将当前子账户停放到 ' + parkedPath);
+    return parkedPath;
+}
+
+/**
+ * 在当前 ~/.codex 内切换子账户：只 move 4 个文件，不碰 ~/.codex_*
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {object} selected 选中的子账户记录
+ * @param {Array<object>} records 全部子账户记录
+ * @param {object} [options] 可选配置，execImpl 用于注入杀进程实现
+ * @returns {Promise<{ skipped: boolean, email?: string }>}
+ */
+async function switchSubAccount(codexDir, selected, records, options) {
+    options = options || {};
+    if (!selected) {
+        throw new Error('未找到要切换的子账户');
+    }
+    if (selected.isCurrent) {
+        console.log('当前已是 ' + selected.displayEmail + '，无需切换');
+        return { skipped: true };
+    }
+
+    var currentRecord = null;
+    records.forEach(function (record) {
+        if (record.isCurrent) {
+            currentRecord = record;
+        }
+    });
+
+    var presentFiles = listPresentSubFiles(codexDir);
+    var unnamedAction = null;
+    if (presentFiles.length > 0 && currentRecord && !currentRecord.accountName) {
+        unnamedAction = await promptUnnamedSubAction();
+    }
+
+    killCodexProcesses(options.execImpl);
+
+    var parkedPath = null;
+    if (presentFiles.length > 0) {
+        if (unnamedAction) {
+            parkedPath = applyUnnamedSubAction(codexDir, unnamedAction);
+        } else {
+            var parkedName = allocateParkedSubDirName(codexDir, currentRecord.accountName);
+            parkedPath = path.join(codexDir, parkedName);
+            moveSubFiles(codexDir, codexDir, parkedPath);
+        }
+    }
+
+    try {
+        moveSubFiles(codexDir, selected.dirPath, codexDir);
+        removeDirIfEmpty(selected.dirPath);
+    } catch (e) {
+        if (parkedPath) {
+            console.error('已将原子账户停放到 ' + parkedPath + '，但启用新子账户失败，请手动恢复');
+        }
+        throw e;
+    }
+
+    console.log('已切换到 ' + selected.displayEmail + '，请重新启动 Codex');
+    return { skipped: false, email: selected.displayEmail };
+}
+
+/**
+ * 移除当前子账户：只把 4 个文件停放到 ~/.codex/juser_*，不删 ~/.codex，不改其它账号目录
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {object|null} currentRecord 当前子账户记录
+ * @param {object} [options] 可选配置
+ * @returns {Promise<{ cancelled: boolean }>}
+ */
+async function removeCurrentSubAccount(codexDir, currentRecord, options) {
+    options = options || {};
+    var confirmAnswer = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirmed',
+        message: '确认把当前子账户停放到 ~/.codex/juser_* 吗？',
+        default: false,
+    }]);
+    if (!confirmAnswer.confirmed) {
+        console.log('已取消移除当前子账户。');
+        return { cancelled: true };
+    }
+
+    var presentFiles = listPresentSubFiles(codexDir);
+    if (presentFiles.length <= 0) {
+        console.log('当前没有可移除的子账户配置。');
+        await maybeCreateCodexEnv(path.dirname(codexDir));
+        return { cancelled: false };
+    }
+
+    var unnamedAction = null;
+    if (!(currentRecord && currentRecord.accountName)) {
+        unnamedAction = await promptUnnamedSubAction();
+    }
+
+    killCodexProcesses(options.execImpl);
+    if (unnamedAction) {
+        applyUnnamedSubAction(codexDir, unnamedAction);
+    } else {
+        var parkedName = allocateParkedSubDirName(codexDir, currentRecord.accountName);
+        var parkedPath = path.join(codexDir, parkedName);
+        moveSubFiles(codexDir, codexDir, parkedPath);
+        console.log('已移除当前子账户，已停放到 ' + parkedPath);
+    }
+
+    await maybeCreateCodexEnv(path.dirname(codexDir));
+    return { cancelled: false };
+}
+
+/**
+ * 当前空间的子账户二级菜单；所有改动限制在 codexDir 内
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {object} [options] 可选配置
+ * @returns {Promise<{ back: boolean }>}
+ */
+async function runSubAccountMenu(codexDir, options) {
+    options = options || {};
+    var records = buildSubAccountRecords(codexDir);
+    var current = null;
+    records.forEach(function (record) {
+        if (record.isCurrent) {
+            current = record;
+        }
+    });
+    var answer = await inquirer.prompt([{
+        type: 'list',
+        name: 'dirPath',
+        message: '请选择要切换的子账户',
+        choices: buildUcxSubChoices(records),
+        default: current ? current.dirPath : undefined,
+    }]);
+
+    if (answer.dirPath === BACK_TO_PARENT) {
+        return { back: true };
+    }
+    if (answer.dirPath === REMOVE_CURRENT_SUB) {
+        await removeCurrentSubAccount(codexDir, current || null, options);
+        return { back: false };
+    }
+
+    var selected = findRecordByDirPath(records, answer.dirPath);
+    await switchSubAccount(codexDir, selected, records, options);
+    return { back: false };
+}
+
 /**
  * 按路径从记录中查找账号
  * @param {Array<object>} records 账号记录
@@ -510,40 +973,57 @@ function findRecordByDirPath(records, dirPath) {
 
 /**
  * 执行 ucx 交互切换
+ * 选中当前 ~/.codex 进入子账户二级菜单；返回上级时重新弹出一级列表
  * @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,
-    }]);
+    while (true) {
+        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;
+        }
 
-    if (answer.dirPath === REMOVE_CURRENT_ACCOUNT) {
-        await removeCurrentAccount(homeDir, current || null, {});
+        var selected = findRecordByDirPath(records, answer.dirPath);
+        if (selected && selected.isCurrent) {
+            var subResult = await runSubAccountMenu(selected.dirPath, {});
+            if (subResult && subResult.back) {
+                continue;
+            }
+            return;
+        }
+        await switchCodexAccount(homeDir, selected, records, {});
         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,
+    REMOVE_CURRENT_SUB: REMOVE_CURRENT_SUB,
+    BACK_TO_PARENT: BACK_TO_PARENT,
+    SUB_DIR_PREFIX: SUB_DIR_PREFIX,
+    SUB_FILE_NAMES: SUB_FILE_NAMES,
     CODEX_ENV_DEMO: CODEX_ENV_DEMO,
     getHomeDir: getHomeDir,
     sanitizeEmailForDir: sanitizeEmailForDir,
     decodeJwtPayload: decodeJwtPayload,
     extractEmailFromTokens: extractEmailFromTokens,
     getOpenAiApiKey: getOpenAiApiKey,
+    readModelProvider: readModelProvider,
+    composeAccountName: composeAccountName,
     readAccountName: readAccountName,
     readAccountEmail: readAccountEmail,
     listCodexAccountDirs: listCodexAccountDirs,
@@ -557,6 +1037,19 @@ runUcx._private = {
     assertCanParkCurrent: assertCanParkCurrent,
     switchCodexAccount: switchCodexAccount,
     removeCurrentAccount: removeCurrentAccount,
+    isSubAccountDirName: isSubAccountDirName,
+    resolvePathInsideCodexDir: resolvePathInsideCodexDir,
+    listSubAccountDirs: listSubAccountDirs,
+    listPresentSubFiles: listPresentSubFiles,
+    moveSubFiles: moveSubFiles,
+    removePresentSubFiles: removePresentSubFiles,
+    allocateParkedSubDirName: allocateParkedSubDirName,
+    buildSubAccountRecords: buildSubAccountRecords,
+    buildSubAccountChoices: buildSubAccountChoices,
+    buildUcxSubChoices: buildUcxSubChoices,
+    switchSubAccount: switchSubAccount,
+    removeCurrentSubAccount: removeCurrentSubAccount,
+    runSubAccountMenu: runSubAccountMenu,
 };
 
 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', 'ucx'];
+var VALID_TARGETS = ['jcc', 'jcx', 'weds', 'ucx', 'jgrok'];
 
 /**
  * 打印 base_parts_ai 入口命令的中文帮助信息
@@ -17,11 +17,12 @@ function printUsage() {
         'base_parts_ai 入口工具',
         '',
         '用法:',
-        '  base_parts_ai                 选择 jcc、jcx、weds 或 ucx 后继续执行',
+        '  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       显示当前版本',
         '',
@@ -57,13 +58,13 @@ function resolveTarget(args) {
 
     return {
         type: 'error',
-        message: '参数无效：有参数时必须先明确指定 jcc、jcx、weds 或 ucx。',
+        message: '参数无效：有参数时必须先明确指定 jcc、jcx、weds、ucx 或 jgrok。',
     };
 }
 
 /**
  * 让用户选择要继续执行的配置工具
- * @returns {Promise<string>} jcc、jcx、weds 或 ucx
+ * @returns {Promise<string>} jcc、jcx、weds、ucx 或 jgrok
  */
 async function selectTarget() {
     var answer = await inquirer.prompt([{
@@ -75,6 +76,7 @@ async function selectTarget() {
             { 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;
@@ -82,7 +84,7 @@ async function selectTarget() {
 
 /**
  * 获取当前包内目标 CLI 脚本路径
- * @param {string} target jcc、jcx、weds 或 ucx
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @returns {string}
  */
 function getTargetScriptPath(target) {
@@ -90,8 +92,8 @@ function getTargetScriptPath(target) {
 }
 
 /**
- * 加载当前包内的 jcc/jcx/weds/ucx 入口函数
- * @param {string} target jcc、jcx、weds 或 ucx
+ * 加载当前包内的 jcc/jcx/weds/ucx/jgrok 入口函数
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @returns {Function}
  */
 function loadTargetCli(target) {
@@ -99,8 +101,8 @@ function loadTargetCli(target) {
 }
 
 /**
- * 同进程执行当前包内的 jcc/jcx/weds/ucx 入口，并临时注入跳过自身升级的环境变量
- * @param {string} target jcc、jcx、weds 或 ucx
+ * 同进程执行当前包内的 jcc/jcx/weds/ucx/jgrok 入口，并临时注入跳过自身升级的环境变量
+ * @param {string} target jcc、jcx、weds、ucx 或 jgrok
  * @param {Array<string>} args 透传给目标入口的参数
  * @param {Function} loader 测试用入口加载函数，默认 loadTargetCli
  * @returns {Promise<number>} 退出码
@@ -113,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,16 +1,17 @@
 {
   "name": "base_parts_ai",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "description": "jaskle base_parts_ai",
   "main": "./main.js",
   "registry": true,
   "directories": {},
   "scripts": {
-    "test": "node ./test_project_md_rename.js && node ./test_main.js && node ./test_jcc.js && node ./test_jcx.js && node ./test_ucx.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"
   },
@@ -18,8 +19,8 @@
     "base_parts_ai": "./main.js",
     "jcc": "./bin/jcc.js",
     "jcx": "./bin/jcx.js",
-    "weds": "./bin/weds.js",
-    "ucx": "./bin/ucx.js"
+    "ucx": "./bin/ucx.js",
+    "jgrok": "./bin/jgrok.js"
   },
   "files": [
     "main.js",