base_parts_ai 1.0.59 → 1.0.61

package/README.md

@@ -38,7 +38,7 @@ ucx
 jgrok
 ```
 
-`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` 存在时会注入子进程环境。
+`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` 倒序去重列出最近 8 条会话，id 在前、名字在后，最新在上并默认选中，选择后再执行 `codex fork <会话id> --yolo`）、直接进入 codex（`codex --yolo`）、退出 ucx；启动 codex 时会等待其执行完成后一起退出并透传其退出码，`~/.codex/.env` 存在时会注入子进程环境。
 
 `jgrok` 若 `~/.grok/.env` 不存在则写入代理示例并打印绝对路径，请编辑后再运行。已存在则把该文件注入环境变量：本机没有 `grok` 时通过腾讯云 npm 源安装 `@xai-official/grok`（安装不注入环境变量），然后启动 `grok`，用户参数原样透传。
 

package/bin/jgrok.js

@@ -32,7 +32,7 @@ function loadLib(libName) {
  */
 async function runCli(args) {
     var buildCfg = getBuildCfg();
-    return await loadLib('jgrok')(args || [], buildCfg);
+    return loadLib('jgrok')(args || [], buildCfg);
 }
 
 if (require.main === module) {

package/lib/jgrok.js

@@ -141,27 +141,54 @@ function buildChildEnv(content) {
 }
 
 /**
- * 启动官方 grok，Windows 走 shell 以便找到 grok.cmd
+ * 前台启动官方 grok 并等待其执行完成，返回其退出码；spawn 失败向上抛错
+ * 与 ucx 的 launchCodex 相同的健壮启动模式：异步 spawn + stdio:'inherit' 等待 close 事件。
+ * 当前 jgrok 没有 inquirer 交互不会抢输入，但启动前仍恢复 cooked 模式、真实启动后立即
+ * 销毁父进程 stdin，防止将来增加交互业务后出现“grok 界面起来但无法输入”的问题
+ * （inquirer 用过 stdin 后父进程挂起的读取会抢走子进程键盘输入）。
  * @param {Array<string>} args 透传给 grok 的参数
  * @param {object} childEnv 注入后的环境变量
- * @param {object} [options] 可选配置，spawnImpl 用于注入 spawnSync
- * @returns {number} grok 退出码
+ * @param {object} [options] 可选配置，spawnImpl 用于注入 spawn
+ * @returns {Promise<number>} grok 退出码
  */
-function spawnGrok(args, childEnv, options) {
+async function spawnGrok(args, childEnv, options) {
     options = options || {};
-    var spawn = options.spawnImpl || childProcess.spawnSync;
-    var result = spawn('grok', args || [], {
+    // 恢复 cooked 模式，给子进程一个干净的终端基线（将来加入 inquirer 交互后尤为关键）
+    if (process.stdin && process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        try {
+            process.stdin.setRawMode(false);
+        } catch (e) {
+            // 模式恢复失败不阻断启动
+        }
+    }
+    var spawn = options.spawnImpl || childProcess.spawn;
+    var child = spawn('grok', args || [], {
         stdio: 'inherit',
         shell: process.platform === 'win32',
         env: childEnv,
-    }) || {};
-    if (result.error) {
-        throw result.error;
-    }
-    if (result.signal) {
-        return 1;
+    });
+    // 真实启动时销毁父进程 stdin，取消可能挂起的读取，把键盘输入完全让给 grok；
+    // 句柄已在 spawn 时复制给子进程，销毁父进程 stdin 不影响 grok。
+    // 注入 spawnImpl 的单测不销毁，避免破坏测试进程自身的 stdin。
+    if (!options.spawnImpl && process.stdin && typeof process.stdin.destroy === 'function') {
+        if (typeof process.stdin.pause === 'function') {
+            process.stdin.pause();
+        }
+        process.stdin.destroy();
     }
-    return typeof result.status === 'number' ? result.status : 0;
+    var exitCode = await new Promise(function (resolve, reject) {
+        child.on('error', function (err) {
+            reject(err);
+        });
+        child.on('close', function (code, signal) {
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(typeof code === 'number' ? code : 0);
+        });
+    });
+    return exitCode;
 }
 
 /**

package/lib/ucx.js

@@ -27,7 +27,7 @@ var REMOVE_CURRENT_SUB = '__remove_current_sub__';
 /** 二级菜单：返回一级账号列表 */
 var BACK_TO_PARENT = '__back_to_parent__';
 
-/** 三级菜单：还原最后一次会话并进入 codex */
+/** 三级菜单：选择历史会话并进入 codex */
 var POST_SWITCH_RESUME = '__post_switch_resume__';
 
 /** 三级菜单：直接进入 codex */
@@ -36,6 +36,12 @@ var POST_SWITCH_DIRECT = '__post_switch_direct__';
 /** 三级菜单：退出 ucx，不执行任何命令 */
 var POST_SWITCH_EXIT = '__post_switch_exit__';
 
+/** 会话列表：返回三级菜单，不执行 fork */
+var POST_SWITCH_RESUME_BACK = '__post_switch_resume_back__';
+
+/** 还原会话时最多列出的最近有效会话数 */
+var RESUME_SESSION_LIMIT = 8;
+
 /** 子账户目录前缀，只出现在当前 ~/.codex 内 */
 var SUB_DIR_PREFIX = 'juser_';
 
@@ -479,19 +485,23 @@ function codexCommandExists(execImpl) {
 }
 
 /**
- * 读取 ~/.codex/session_index.jsonl 的最后一次会话记录：倒序跳过坏行，取第一条含非空 id 的记录
+ * 读取 ~/.codex/session_index.jsonl 最近若干条有效会话：倒序跳过坏行，按 id 去重
  * @param {string} homeDir 用户主目录
- * @returns {{ id: string, threadName: string }|null} 无有效记录时返回 null
+ * @param {number} [limit] 最多返回条数，默认 RESUME_SESSION_LIMIT
+ * @returns {Array<{ id: string, threadName: string }>} 新到旧；无有效记录时为空数组
  */
-function readLastSessionRecord(homeDir) {
+function readRecentSessionRecords(homeDir, limit) {
+    var max = typeof limit === 'number' && limit > 0 ? limit : RESUME_SESSION_LIMIT;
     var indexPath = path.join(homeDir, '.codex', 'session_index.jsonl');
     var content = '';
     try {
         content = fs.readFileSync(indexPath, 'utf8');
     } catch (e) {
-        return null;
+        return [];
     }
     var lines = content.split(/\r?\n/);
+    var seen = {};
+    var records = [];
     for (var i = lines.length - 1; i >= 0; i -= 1) {
         var line = lines[i].trim();
         if (!line) {
@@ -500,16 +510,48 @@ function readLastSessionRecord(homeDir) {
         try {
             var record = JSON.parse(line);
             if (record && typeof record.id === 'string' && record.id.trim()) {
-                return {
-                    id: record.id.trim(),
+                var id = record.id.trim();
+                if (seen[id]) {
+                    continue;
+                }
+                seen[id] = true;
+                records.push({
+                    id: id,
                     threadName: typeof record.thread_name === 'string' ? record.thread_name : '',
-                };
+                });
+                if (records.length >= max) {
+                    break;
+                }
             }
         } catch (e) {
             // 半行写入等坏行跳过，继续向前找
         }
     }
-    return null;
+    return records;
+}
+
+/**
+ * 读取 ~/.codex/session_index.jsonl 的最后一次会话记录
+ * @param {string} homeDir 用户主目录
+ * @returns {{ id: string, threadName: string }|null} 无有效记录时返回 null
+ */
+function readLastSessionRecord(homeDir) {
+    var records = readRecentSessionRecords(homeDir, 1);
+    return records.length ? records[0] : null;
+}
+
+/**
+ * 会话选项展示名：有 thread_name 时为「id  名字」，否则只用 id
+ * @param {{ id: string, threadName: string }} session 会话记录
+ * @returns {string}
+ */
+function formatSessionChoiceName(session) {
+    var name = session && typeof session.threadName === 'string' ? session.threadName.trim() : '';
+    var id = session && session.id ? session.id : '';
+    if (name) {
+        return id + '  ' + name;
+    }
+    return id;
 }
 
 /**
@@ -1025,25 +1067,41 @@ async function removeCurrentSubAccount(codexDir, currentRecord, options) {
 }
 
 /**
- * 三级菜单选项：还原最后一次会话 / 直接进入 / 退出，固定顺序
+ * 三级菜单选项：选择历史会话 / 直接进入 / 退出，固定顺序
  * @returns {Array<object>}
  */
 function buildPostSwitchChoices() {
     return [
-        { name: '还原最后一次会话并进入 codex', value: POST_SWITCH_RESUME },
+        { name: '选择历史会话并进入 codex', value: POST_SWITCH_RESUME },
         { name: '直接进入 codex', value: POST_SWITCH_DIRECT },
         { name: '退出 ucx', value: POST_SWITCH_EXIT },
     ];
 }
 
 /**
- * 启动 codex 并等待其执行完成，返回子进程退出码；codex 缺失时提示并返回 null
+ * 还原会话列表：最近若干条会话 + 返回上级，固定返回项在末尾
+ * @param {Array<{ id: string, threadName: string }>} sessions 新到旧的会话
+ * @returns {Array<object>}
+ */
+function buildResumeSessionChoices(sessions) {
+    var choices = (sessions || []).map(function (session) {
+        return { name: formatSessionChoiceName(session), value: session.id };
+    });
+    choices.push({ name: '*返回上级*', value: POST_SWITCH_RESUME_BACK });
+    return choices;
+}
+
+/**
+ * 前台启动 codex 并等待其执行完成，返回其退出码；codex 缺失时提示并返回 null，spawn 失败向上抛错
+ * 关键点：inquirer 菜单用过 stdin 后，父进程的 stdin 上可能仍挂着操作系统层面的读取，
+ * 会抢走子进程的键盘输入（codex 界面起来但无法输入）；jgrok 没这个问题是因为它从不碰 stdin。
+ * 因此启动前恢复 cooked 模式，真实启动时 spawn 后立即销毁父进程 stdin，把输入完全让给 codex。
  * @param {Array<string>} args 传给 codex 的参数
  * @param {string} homeDir 用户主目录
  * @param {object} [options] 可选配置，spawnImpl/execImpl 用于单测注入
- * @returns {number|null}
+ * @returns {Promise<number|null>}
  */
-function launchCodex(args, homeDir, options) {
+async function launchCodex(args, homeDir, options) {
     options = options || {};
     // 测试环境且未注入实现时跳过，避免真实启动 codex
     if (process.env.JCC_TEST_HOME && !options.spawnImpl) {
@@ -1054,24 +1112,46 @@ function launchCodex(args, homeDir, options) {
         console.error('未检测到 codex 命令，请先安装 Codex CLI 后重试。');
         return null;
     }
-    var spawn = options.spawnImpl || childProcess.spawnSync;
-    var result = spawn('codex', args || [], {
+    // 恢复 cooked 模式，给子进程一个与 jgrok 场景一致的干净终端基线
+    if (process.stdin && process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        try {
+            process.stdin.setRawMode(false);
+        } catch (e) {
+            // 模式恢复失败不阻断启动
+        }
+    }
+    var spawn = options.spawnImpl || childProcess.spawn;
+    var child = spawn('codex', args || [], {
         stdio: 'inherit',
         shell: process.platform === 'win32',
         env: buildCodexChildEnv(homeDir),
-    }) || {};
-    if (result.error) {
-        throw result.error;
-    }
-    if (result.signal) {
-        return 1;
+    });
+    // 真实启动时销毁父进程 stdin，取消挂起读取；句柄已在 spawn 时复制给子进程，不受影响。
+    // 注入 spawnImpl 的单测不销毁，避免破坏测试进程自身的 stdin。
+    if (!options.spawnImpl && process.stdin && typeof process.stdin.destroy === 'function') {
+        if (typeof process.stdin.pause === 'function') {
+            process.stdin.pause();
+        }
+        process.stdin.destroy();
     }
-    return typeof result.status === 'number' ? result.status : 0;
+    var exitCode = await new Promise(function (resolve, reject) {
+        child.on('error', function (err) {
+            reject(err);
+        });
+        child.on('close', function (code, signal) {
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(typeof code === 'number' ? code : 0);
+        });
+    });
+    return exitCode;
 }
 
 /**
- * 子账号切换后的三级菜单：还原最后一次会话 / 直接进入 codex / 退出 ucx
- * 还原时读 ~/.codex/session_index.jsonl 取最后一次会话 id 后执行 codex fork <id> --yolo
+ * 子账号切换后的三级菜单：选择历史会话 / 直接进入 codex / 退出 ucx
+ * 还原时读 ~/.codex/session_index.jsonl 倒序去重列出最近 8 条，最新在上并默认选中，选中后再 fork
  * @param {string} homeDir 用户主目录
  * @param {object} [options] 可选配置，spawnImpl/execImpl 用于单测注入
  * @returns {Promise<number|undefined>} codex 退出码；未启动 codex 时为 undefined
@@ -1093,15 +1173,34 @@ async function runPostSwitchMenu(homeDir, options) {
             return launchCodex(['--yolo'], homeDir, options);
         }
 
-        // 还原最后一次会话：无会话记录时提示并重新选择，用户可改选直接进入
-        var session = readLastSessionRecord(homeDir);
-        if (!session) {
+        // 还原会话：无记录时提示并重选；有记录则列出最近 8 条供选择，默认最新
+        var sessions = readRecentSessionRecords(homeDir, RESUME_SESSION_LIMIT);
+        if (!sessions.length) {
             console.log('未在 ~/.codex/session_index.jsonl 中找到会话记录，无法还原。');
             continue;
         }
-        var display = session.threadName || session.id;
-        console.log('正在还原最后一次会话：' + display);
-        return launchCodex(['fork', session.id, '--yolo'], homeDir, options);
+        var sessionAnswer = await inquirer.prompt([{
+            type: 'list',
+            name: 'sessionId',
+            message: '请选择要还原的会话',
+            choices: buildResumeSessionChoices(sessions),
+            default: sessions[0].id,
+        }]);
+        if (sessionAnswer.sessionId === POST_SWITCH_RESUME_BACK) {
+            continue;
+        }
+        var selectedSession = null;
+        sessions.forEach(function (item) {
+            if (item.id === sessionAnswer.sessionId) {
+                selectedSession = item;
+            }
+        });
+        if (!selectedSession) {
+            continue;
+        }
+        var display = selectedSession.threadName || selectedSession.id;
+        console.log('正在还原会话：' + display);
+        return launchCodex(['fork', selectedSession.id, '--yolo'], homeDir, options);
     }
 }
 
@@ -1207,6 +1306,8 @@ runUcx._private = {
     POST_SWITCH_RESUME: POST_SWITCH_RESUME,
     POST_SWITCH_DIRECT: POST_SWITCH_DIRECT,
     POST_SWITCH_EXIT: POST_SWITCH_EXIT,
+    POST_SWITCH_RESUME_BACK: POST_SWITCH_RESUME_BACK,
+    RESUME_SESSION_LIMIT: RESUME_SESSION_LIMIT,
     SUB_DIR_PREFIX: SUB_DIR_PREFIX,
     SUB_FILE_NAMES: SUB_FILE_NAMES,
     CODEX_ENV_DEMO: CODEX_ENV_DEMO,
@@ -1246,7 +1347,10 @@ runUcx._private = {
     parseCodexEnvContent: parseCodexEnvContent,
     buildCodexChildEnv: buildCodexChildEnv,
     codexCommandExists: codexCommandExists,
+    readRecentSessionRecords: readRecentSessionRecords,
     readLastSessionRecord: readLastSessionRecord,
+    formatSessionChoiceName: formatSessionChoiceName,
+    buildResumeSessionChoices: buildResumeSessionChoices,
     buildPostSwitchChoices: buildPostSwitchChoices,
     launchCodex: launchCodex,
     runPostSwitchMenu: runPostSwitchMenu,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "base_parts_ai",
-  "version": "1.0.59",
+  "version": "1.0.61",
   "description": "jaskle base_parts_ai",
   "main": "./main.js",
   "registry": true,