base_parts_ai 1.0.57 → 1.0.59

package/README.md

@@ -38,7 +38,7 @@ 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_*` 账号目录。二级选中子账户后（含选中当前无需切换）会进入下一级选择：还原最后一次会话并进入 codex（读 `~/.codex/session_index.jsonl` 取最后一次会话 id 后执行 `codex fork <会话id> --yolo`）、直接进入 codex（`codex --yolo`）、退出 ucx；启动 codex 时会等待其执行完成后一起退出并透传其退出码，`~/.codex/.env` 存在时会注入子进程环境。
 
 `jgrok` 若 `~/.grok/.env` 不存在则写入代理示例并打印绝对路径，请编辑后再运行。已存在则把该文件注入环境变量：本机没有 `grok` 时通过腾讯云 npm 源安装 `@xai-official/grok`（安装不注入环境变量），然后启动 `grok`，用户参数原样透传。
 

package/bin/ucx.js

@@ -29,45 +29,51 @@ function loadLib(libName) {
 
 /**
  * 拉取远程配置（含自动升级）后执行账号切换
- * @returns {Promise<void>}
+ * @returns {Promise<number|undefined>} 子账户三级菜单启动过 codex 时返回其退出码
  */
 async function runSwitch() {
     var buildCfg = getBuildCfg();
     var utils = loadLib('ai_utils');
     await utils.fetchConfig(buildCfg);
     await utils.showNotice();
-    await loadLib('ucx')({}, buildCfg);
+    return loadLib('ucx')({}, buildCfg);
 }
 
 /**
  * 运行 ucx CLI，可供命令行直接执行或被 base_parts_ai require 调用
  * @param {Array<string>} args 用户参数，不包含 node 和脚本路径
- * @returns {Promise<void>}
+ * @returns {Promise<number|undefined>} 透传 codex 退出码
  */
 async function runCli(args) {
     var cliArgs = (args || []).slice();
     var program = new Command();
+    var exitCode;
 
     program
         .name('ucx')
-        .description('通过目录改名切换 Codex 账号')
+        .description('通过目录改名切换 Codex 账号，选中当前目录可切换其子账户')
         .version(packageJson.version)
         .action(async function () {
-            await runSwitch();
+            exitCode = await runSwitch();
         });
 
     // 无参数时直接进入切换，避免 commander 空参数不触发根 action
     if (cliArgs.length <= 0) {
-        await runSwitch();
-        return;
+        return runSwitch();
     }
 
     // 使用 from:user 避免读取或修改全局 process.argv，便于被主入口 require 调用
     await program.parseAsync(cliArgs, { from: 'user' });
+    return exitCode;
 }
 
 if (require.main === module) {
-    runCli(process.argv.slice(2)).catch(function (err) {
+    runCli(process.argv.slice(2)).then(function (code) {
+        // 启动过 codex 时与其共用退出码，便于脚本感知 codex 结果
+        if (typeof code === 'number') {
+            process.exit(code);
+        }
+    }).catch(function (err) {
         console.error('ucx 执行失败:', err.message);
         process.exit(1);
     });

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,27 @@ 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 POST_SWITCH_RESUME = '__post_switch_resume__';
+
+/** 三级菜单：直接进入 codex */
+var POST_SWITCH_DIRECT = '__post_switch_direct__';
+
+/** 三级菜单：退出 ucx，不执行任何命令 */
+var POST_SWITCH_EXIT = '__post_switch_exit__';
+
+/** 子账户目录前缀，只出现在当前 ~/.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 +74,7 @@ function isCodexAccountDirName(name) {
 
 /**
  * 将账号名中 Windows 非法文件名字符替换为下划线，保留 @.+-
- * @param {string} accountName 邮箱或脱敏 Key 短名
+ * @param {string} accountName 组合展示名（配置名_Key_Email）
  * @returns {string}
  */
 function sanitizeEmailForDir(accountName) {
@@ -123,20 +146,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 '';
     }
-    return extractEmailFromTokens(auth.tokens);
+    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 composeAccountName(configName, maskedKey, email);
 }
 
 /**
@@ -225,7 +297,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 +353,7 @@ async function maybeCreateCodexEnv(homeDir) {
 }
 
 /**
- * 移除当前账号：有登录信息则停放改名；三无目录与切换时相同，询问删除或手工命名
+ * 移除当前账号：有登录信息则停放改名（不删除）；三无目录与切换时相同，询问删除或手工命名
  * @param {string} homeDir 用户主目录
  * @param {object|null} currentRecord 当前 ~/.codex 记录
  * @param {object} [options] 可选配置，execImpl 用于注入杀进程实现
@@ -292,7 +364,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) {
@@ -344,10 +416,106 @@ function killCodexProcesses(execImpl) {
     });
 }
 
+/**
+ * 解析 .env 文本为键值对象：跳过注释与空行，去掉成对引号
+ * @param {string} content .env 文件内容
+ * @returns {object}
+ */
+function parseCodexEnvContent(content) {
+    var result = {};
+    String(content || '').split(/\r?\n/).forEach(function (line) {
+        var trimmed = line.trim();
+        if (!trimmed || trimmed.indexOf('#') === 0) {
+            return;
+        }
+        var eqIndex = trimmed.indexOf('=');
+        if (eqIndex <= 0) {
+            return;
+        }
+        var key = trimmed.slice(0, eqIndex).trim();
+        var value = trimmed.slice(eqIndex + 1).trim();
+        if (value.length >= 2 && ((value[0] === '"' && value[value.length - 1] === '"') || (value[0] === '\'' && value[value.length - 1] === '\''))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    });
+    return result;
+}
+
+/**
+ * 构建 codex 子进程环境：在当前进程环境之上合并 ~/.codex/.env，确保子账户切换后代理与 Key 立即生效
+ * @param {string} homeDir 用户主目录
+ * @returns {object}
+ */
+function buildCodexChildEnv(homeDir) {
+    var envPath = path.join(homeDir, '.codex', '.env');
+    var childEnv = Object.assign({}, process.env);
+    if (!fs.existsSync(envPath)) {
+        return childEnv;
+    }
+    try {
+        var parsed = parseCodexEnvContent(fs.readFileSync(envPath, 'utf8'));
+        return Object.assign(childEnv, parsed);
+    } catch (e) {
+        // .env 读取失败时退回当前进程环境，不阻断启动
+        return childEnv;
+    }
+}
+
+/**
+ * 检测本机是否存在 codex 命令；测试环境或注入 exec 时避免触碰宿主机
+ * @param {Function} [execImpl] 可注入的 execSync，便于单测
+ * @returns {boolean}
+ */
+function codexCommandExists(execImpl) {
+    var exec = execImpl || childProcess.execSync;
+    var cmd = process.platform === 'win32' ? 'where codex' : 'which codex';
+    try {
+        exec(cmd, { stdio: 'ignore' });
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**
+ * 读取 ~/.codex/session_index.jsonl 的最后一次会话记录：倒序跳过坏行，取第一条含非空 id 的记录
+ * @param {string} homeDir 用户主目录
+ * @returns {{ id: string, threadName: string }|null} 无有效记录时返回 null
+ */
+function readLastSessionRecord(homeDir) {
+    var indexPath = path.join(homeDir, '.codex', 'session_index.jsonl');
+    var content = '';
+    try {
+        content = fs.readFileSync(indexPath, 'utf8');
+    } catch (e) {
+        return null;
+    }
+    var lines = content.split(/\r?\n/);
+    for (var i = lines.length - 1; i >= 0; i -= 1) {
+        var line = lines[i].trim();
+        if (!line) {
+            continue;
+        }
+        try {
+            var record = JSON.parse(line);
+            if (record && typeof record.id === 'string' && record.id.trim()) {
+                return {
+                    id: record.id.trim(),
+                    threadName: typeof record.thread_name === 'string' ? record.thread_name : '',
+                };
+            }
+        } catch (e) {
+            // 半行写入等坏行跳过，继续向前找
+        }
+    }
+    return null;
+}
+
 /**
  * 为当前账号分配不冲突的停放目录名；同名已存在时追加 _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 +604,7 @@ function assertCanParkCurrent(homeDir, currentRecord) {
 
 /**
  * 执行账号目录切换：停放当前 .codex，再把选中目录改名为 .codex
- * 当前为三无目录时先询问删除或手工命名，名称不写回 auth.json
+ * 当前为三无目录（无配置名、无 Key、无登录信息）时先询问删除或手工命名，名称不写回 auth.json
  * @param {string} homeDir 用户主目录
  * @param {object} selected 选中的账号记录
  * @param {Array<object>} records 全部账号记录
@@ -492,6 +660,489 @@ 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 };
+}
+
+/**
+ * 三级菜单选项：还原最后一次会话 / 直接进入 / 退出，固定顺序
+ * @returns {Array<object>}
+ */
+function buildPostSwitchChoices() {
+    return [
+        { name: '还原最后一次会话并进入 codex', value: POST_SWITCH_RESUME },
+        { name: '直接进入 codex', value: POST_SWITCH_DIRECT },
+        { name: '退出 ucx', value: POST_SWITCH_EXIT },
+    ];
+}
+
+/**
+ * 启动 codex 并等待其执行完成，返回子进程退出码；codex 缺失时提示并返回 null
+ * @param {Array<string>} args 传给 codex 的参数
+ * @param {string} homeDir 用户主目录
+ * @param {object} [options] 可选配置，spawnImpl/execImpl 用于单测注入
+ * @returns {number|null}
+ */
+function launchCodex(args, homeDir, options) {
+    options = options || {};
+    // 测试环境且未注入实现时跳过，避免真实启动 codex
+    if (process.env.JCC_TEST_HOME && !options.spawnImpl) {
+        console.log('测试环境跳过启动 codex。');
+        return null;
+    }
+    if (!codexCommandExists(options.execImpl)) {
+        console.error('未检测到 codex 命令，请先安装 Codex CLI 后重试。');
+        return null;
+    }
+    var spawn = options.spawnImpl || childProcess.spawnSync;
+    var result = spawn('codex', args || [], {
+        stdio: 'inherit',
+        shell: process.platform === 'win32',
+        env: buildCodexChildEnv(homeDir),
+    }) || {};
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.signal) {
+        return 1;
+    }
+    return typeof result.status === 'number' ? result.status : 0;
+}
+
+/**
+ * 子账号切换后的三级菜单：还原最后一次会话 / 直接进入 codex / 退出 ucx
+ * 还原时读 ~/.codex/session_index.jsonl 取最后一次会话 id 后执行 codex fork <id> --yolo
+ * @param {string} homeDir 用户主目录
+ * @param {object} [options] 可选配置，spawnImpl/execImpl 用于单测注入
+ * @returns {Promise<number|undefined>} codex 退出码；未启动 codex 时为 undefined
+ */
+async function runPostSwitchMenu(homeDir, options) {
+    options = options || {};
+    for (;;) {
+        var answer = await inquirer.prompt([{
+            type: 'list',
+            name: 'action',
+            message: '请选择接下来的操作',
+            choices: buildPostSwitchChoices(),
+        }]);
+
+        if (answer.action === POST_SWITCH_EXIT) {
+            return undefined;
+        }
+        if (answer.action === POST_SWITCH_DIRECT) {
+            return launchCodex(['--yolo'], homeDir, options);
+        }
+
+        // 还原最后一次会话：无会话记录时提示并重新选择，用户可改选直接进入
+        var session = readLastSessionRecord(homeDir);
+        if (!session) {
+            console.log('未在 ~/.codex/session_index.jsonl 中找到会话记录，无法还原。');
+            continue;
+        }
+        var display = session.threadName || session.id;
+        console.log('正在还原最后一次会话：' + display);
+        return launchCodex(['fork', session.id, '--yolo'], homeDir, options);
+    }
+}
+
+/**
+ * 当前空间的子账户二级菜单；所有改动限制在 codexDir 内
+ * @param {string} codexDir 当前 ~/.codex
+ * @param {object} [options] 可选配置
+ * @returns {Promise<{ back: boolean, exitCode?: number }>}
+ */
+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);
+    // 切换完成（含“已是当前子账户”的跳过场景）后进入三级菜单，可选择还原会话/直接进入 codex/退出
+    var exitCode = await runPostSwitchMenu(path.dirname(codexDir), options);
+    return { back: false, exitCode: exitCode };
+}
+
 /**
  * 按路径从记录中查找账号
  * @param {Array<object>} records 账号记录
@@ -510,40 +1161,62 @@ function findRecordByDirPath(records, dirPath) {
 
 /**
  * 执行 ucx 交互切换
+ * 选中当前 ~/.codex 进入子账户二级菜单；返回上级时重新弹出一级列表
  * @param {object} cmd commander 选项（当前无业务字段）
  * @param {object} buildCfg 含 homeDir 的配置
- * @returns {Promise<void>}
+ * @param {object} [options] 可选配置，spawnImpl/execImpl 用于单测注入
+ * @returns {Promise<number|undefined>} 启动过 codex 时返回其退出码
  */
-async function runUcx(cmd, buildCfg) {
+async function runUcx(cmd, buildCfg, options) {
+    options = options || {};
     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,
-    }]);
+    for (;;) {
+        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, {});
+        if (answer.dirPath === REMOVE_CURRENT_ACCOUNT) {
+            await removeCurrentAccount(homeDir, current || null, options);
+            return;
+        }
+
+        var selected = findRecordByDirPath(records, answer.dirPath);
+        if (selected && selected.isCurrent) {
+            var subResult = await runSubAccountMenu(selected.dirPath, options);
+            if (subResult && subResult.back) {
+                continue;
+            }
+            return subResult ? subResult.exitCode : undefined;
+        }
+        await switchCodexAccount(homeDir, selected, records, options);
         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,
+    POST_SWITCH_RESUME: POST_SWITCH_RESUME,
+    POST_SWITCH_DIRECT: POST_SWITCH_DIRECT,
+    POST_SWITCH_EXIT: POST_SWITCH_EXIT,
+    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 +1230,26 @@ 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,
+    parseCodexEnvContent: parseCodexEnvContent,
+    buildCodexChildEnv: buildCodexChildEnv,
+    codexCommandExists: codexCommandExists,
+    readLastSessionRecord: readLastSessionRecord,
+    buildPostSwitchChoices: buildPostSwitchChoices,
+    launchCodex: launchCodex,
+    runPostSwitchMenu: runPostSwitchMenu,
 };
 
 module.exports = runUcx;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "base_parts_ai",
-  "version": "1.0.57",
+  "version": "1.0.59",
   "description": "jaskle base_parts_ai",
   "main": "./main.js",
   "registry": true,
@@ -19,7 +19,6 @@
     "base_parts_ai": "./main.js",
     "jcc": "./bin/jcc.js",
     "jcx": "./bin/jcx.js",
-    "weds": "./bin/weds.js",
     "ucx": "./bin/ucx.js",
     "jgrok": "./bin/jgrok.js"
   },