@seamnet/client 0.20.0 → 0.20.1

package/bin/seam.js

@@ -499,16 +499,23 @@ async function cmdTerm(subAction, restArgs) {
     if (!values.session) output(false, '--session required');
     // 关之前查 registry：这个 session 是否绑着一个 guardian
     let guardianEntry = null;
+    let registryReadError = null;
     try {
       const { readAll } = await import('../lib/registry.js');
       guardianEntry = readAll().find((e) => e.tmux_session === values.session) || null;
-    } catch {}
+    } catch (e) {
+      // registry 读失败不静默——stop 杀了 guardian 不能悄无声息
+      registryReadError = e.message;
+    }
     try {
       const { kind } = tmuxUtils.stopTerm(values.session);
       const result = { session: values.session, kind, stopped: true };
       if (guardianEntry) {
         result.guardian_killed = true;
         result.warning = `注意：已一并终止该 home 的 guardian（userId=${guardianEntry.userId}, home=${guardianEntry.seam_home}）`;
+      } else if (registryReadError) {
+        result.warning = `registry 读取失败（${registryReadError}）——无法确认该会话是否绑 guardian；`
+          + `若这是 cc 会话（kind=${kind}），guardian 可能已随会话一并终止`;
       } else if (kind === 'cc') {
         result.warning = '注意：这是个 cc 会话——若它绑着 guardian，guardian 已随会话一并终止';
       }
@@ -532,11 +539,13 @@ async function cmdTerm(subAction, restArgs) {
     if (!values.session) output(false, '--session required');
     const continueSession = values['no-continue'] ? false : true;
     try {
-      const ok = await tmuxUtils.restartTerm(values.session, { continueSession });
-      if (ok) {
-        output(true, { session: values.session, restarted: true });
+      const r = await tmuxUtils.restartTerm(values.session, { continueSession });
+      if (r.ok) {
+        const result = { session: values.session, restarted: true, startCmd: r.startCmd };
+        if (r.warning) result.warning = r.warning;
+        output(true, result);
       } else {
-        output(false, 'restart failed: 终端未在超时内退出或重启');
+        output(false, r.warning || 'restart failed: 终端未在超时内退出或重启');
       }
     } catch (e) {
       output(false, e.message);

package/lib/guardian.js

@@ -253,13 +253,14 @@ export async function guardianRun() {
     setTimeout(async () => {
       try {
         const { restartTerm } = require('./tmux-utils.cjs');
-        const ok = await restartTerm(safeSession, { socketPath: ccSocket, continueSession: true });
-        if (ok) {
+        const r = await restartTerm(safeSession, { socketPath: ccSocket, continueSession: true });
+        if (r.ok) {
           guardianState.set('cc_restarted', new Date().toISOString());
           if (isUpgradeRestart) guardianState.delete('pending_upgrade_restart');
           hub.logger('guardian').info('cc_restart_injected');
+          if (r.warning) hub.logger('guardian').warn('cc_restart_warning', { warning: r.warning });
         } else {
-          hub.logger('guardian').error('cc_restart_failed', new Error('restartTerm returned false'));
+          hub.logger('guardian').error('cc_restart_failed', new Error(r.warning || 'restartTerm returned ok:false'));
         }
       } catch (e) {
         hub.logger('guardian').error('cc_restart_failed', e);

package/lib/tmux-utils.cjs

@@ -5,8 +5,8 @@
  * 这层与 pane 里跑什么无关。交互语义（审批流、idle 判断等）故意不抽象——
  * 由操作者读屏自己决定按什么键。
  *
- * 唯一的 per-kind 知识：KIND_CMD 表（kind → 默认启动命令）；restart 时
- * cc 走优雅 /exit（跑 Stop hook 保命），codex 走 kill 重起。
+ * 唯一的 per-kind 知识：KIND_CMD 表（kind → 启动/续命/退出/超时）。restart
+ * 时 cc 与 codex 都走对称的优雅路径，差别全在表里。
  */
 
 const { execSync } = require('node:child_process');
@@ -15,11 +15,28 @@ const { basename } = require('node:path');
 
 const EXEC_OPTS = { encoding: 'utf8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] };
 
-// kind → 默认启动命令。新增 kind 在这里加一行即可（kind 是数据，不是命令树）。
+// kind → 启动命令族。声明式数据小表，不是 adapter。新增 kind 加一行即可。
+// - fresh：全新会话的启动命令
+// - resume：续上一次会话的命令（restart 默认走这个；--no-continue 走 fresh）
+// - exit：TUI 内的优雅退出命令（restart 发它 + Enter）
+// - downTimeout：发了 exit 后等进程退出的轮询超时（ms）
 const KIND_CMD = {
-  cc: 'claude --dangerously-skip-permissions',
-  codex: 'codex -m gpt-5.4',
-  shell: 'bash',
+  cc: {
+    fresh: 'claude --dangerously-skip-permissions',
+    resume: 'claude --dangerously-skip-permissions --continue',
+    exit: '/exit',
+    downTimeout: 120000, // cc 退出跑 Stop hook（auto-save / semantic_memory）要 ~90s
+  },
+  codex: {
+    fresh: 'codex -m gpt-5.4',
+    resume: 'codex resume --last',
+    exit: '/exit',
+    downTimeout: 60000, // 实测 codex /exit ~25s（退出存 session），留余量
+  },
+  shell: {
+    fresh: 'bash',
+    // shell 无优雅 restart——restartTerm 对 shell 直接报错
+  },
 };
 const KIND_PREFIX = { cc: 'cc', codex: 'codex', shell: 'sh' };
 
@@ -33,7 +50,14 @@ function sleep(ms) {
 
 /**
  * 检测 session 里跑的是什么：'cc' | 'codex' | 'shell'。session 不存在返回 null。
- * 按 pane 进程及其子进程的 comm 判断。
+ *
+ * 从 pane_pid BFS 进程子树，遇到第一个 comm 含 claude/codex 的进程即返回——
+ * 「最浅命中」。npm 装的 codex 是 node 包装脚本（comm 看到的是 node/MainThread），
+ * 真 codex 是更深一层的 Rust 二进制（comm=codex），所以必须穿透子树。
+ *
+ * 为什么是「最浅命中」而非「收集全部」：cc 会话可能 spawn codex 子进程
+ * （比如 AI 用 codex skill）——那个 codex 在很深的层。最浅命中保证最外层的
+ * 那个有意义进程（panePid 处或附近的 claude）决定 kind，不被深层 codex 干扰。
  */
 function detectKind(session, socketPath) {
   const tmux = tmuxCmd(socketPath);
@@ -43,17 +67,35 @@ function detectKind(session, socketPath) {
   } catch {
     return null;
   }
-  const comms = [];
-  try {
-    comms.push(execSync(`ps -o comm= -p ${panePid} 2>/dev/null`, EXEC_OPTS).trim());
-  } catch {}
+  let table;
   try {
-    const children = execSync(`ps -o comm= --ppid ${panePid} 2>/dev/null`, EXEC_OPTS).trim();
-    if (children) comms.push(children);
-  } catch {}
-  const joined = comms.join(' ').toLowerCase();
-  if (joined.includes('claude')) return 'cc';
-  if (joined.includes('codex')) return 'codex';
+    table = execSync('ps -e -o pid=,ppid=,comm=', { ...EXEC_OPTS, maxBuffer: 4 * 1024 * 1024 });
+  } catch {
+    return 'shell';
+  }
+  const childrenOf = new Map();
+  const commOf = new Map();
+  for (const line of table.split('\n')) {
+    const m = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const [, pid, ppid, comm] = m;
+    commOf.set(pid, comm);
+    if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
+    childrenOf.get(ppid).push(pid);
+  }
+  // BFS：最浅命中即返回
+  const queue = [String(panePid)];
+  const seen = new Set();
+  let guard = 0;
+  while (queue.length && guard++ < 5000) {
+    const pid = queue.shift();
+    if (seen.has(pid)) continue;
+    seen.add(pid);
+    const comm = (commOf.get(pid) || '').toLowerCase();
+    if (comm.includes('claude')) return 'cc';
+    if (comm.includes('codex')) return 'codex';
+    for (const c of childrenOf.get(pid) || []) queue.push(c);
+  }
   return 'shell';
 }
 
@@ -75,10 +117,9 @@ function listTerms(socketPath) {
 /**
  * 读 session 屏幕。默认 last N 行；full=true 读整屏 + scrollback 历史。
  *
- * 实现：一律 `capture-pane -p -S -` 抓全量，在 JS 里去掉尾部空行再切最后 N 行。
+ * 一律 `capture-pane -p -S -` 抓全量，在 JS 里去掉尾部空行再切最后 N 行。
  * 不用 shell `| tail`——capture-pane 会把光标下方的空 viewport 行也输出，
- * shell 的 tail 先抓到那些空行，内容稀疏的会话（shell / 刚起的 codex）就读不到东西。
- * capture-pane 受 tmux history-limit 限制（默认 2000 行），输出有界。
+ * shell 的 tail 先抓到空行，内容稀疏的会话就读不到东西。
  */
 function readTerm(session, { lines = 20, full = false, socketPath } = {}) {
   const tmux = tmuxCmd(socketPath);
@@ -106,7 +147,6 @@ function sendTerm(session, { text, noEnter = false, keys = [], socketPath } = {}
   }
   if (hasText) {
     execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(text)}`, EXEC_OPTS);
-    // 自动 Enter：仅 text-only 且未抑制时。混发按键 = 手动模式，不惊喜回车。
     if (!noEnter && !hasKeys) {
       execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
     }
@@ -139,7 +179,7 @@ function startTerm({ kind, cmd, session, dir, socketPath } = {}) {
   const cwdArg = dir ? `-c "${dir}"` : '';
   execSync(`${tmux} new-session -d -s "${sessionName}" ${cwdArg}`.trim(), { ...EXEC_OPTS, timeout: 10000 });
   // kind=shell 且无 --cmd：new-session 本身就是 bash，不必再 send。
-  const startCmd = cmd || KIND_CMD[kind];
+  const startCmd = cmd || KIND_CMD[kind].fresh;
   if (cmd || kind !== 'shell') {
     execSync(`${tmux} send-keys -t "${sessionName}" -l ${JSON.stringify(startCmd)}`, EXEC_OPTS);
     execSync(`${tmux} send-keys -t "${sessionName}" Enter`, EXEC_OPTS);
@@ -148,20 +188,47 @@ function startTerm({ kind, cmd, session, dir, socketPath } = {}) {
 }
 
 /**
- * restart 通用骨架：停 → 轮询确认停了 → 起 → 轮询确认起了 → 失败 C-c 重试一次。
- * 0.17.1 的「别在状态真变之前动作」教训对所有 kind 通用——差别只在「怎么停」。
+ * restart 通用骨架：停 → 轮询确认停了 → 起 → 轮询确认起了 → 5s 存活复检。
+ * 返回 { ok, warning }。
+ *
+ * 三个兜底（0.20.1 加）：
+ * - poll-down 超时：强制 kill（C-c → 不行再 kill pane 子进程）+ warning，然后照常 relaunch
+ * - poll-up 后 ~5s 存活复检：化解「起来一瞬间被检测到、随即自更新退出」的假 success
+ * - poll-up 失败：C-c 清半行重试一次
  */
 async function restartSkeleton(session, socketPath, { targetKind, stopAction, downTimeout, startCmd }) {
   const tmux = tmuxCmd(socketPath);
+  let warning = null;
+
+  // 1. 停
   stopAction();
-  // poll-down：轮询直到 kind 不再是 targetKind
+
+  // 2. poll-down：轮询直到 kind 不再是 targetKind；超时强制 kill 兜底
   const downDeadline = Date.now() + downTimeout;
   while (detectKind(session, socketPath) === targetKind) {
-    if (Date.now() >= downDeadline) return false;
+    if (Date.now() >= downDeadline) {
+      warning = `${targetKind} 未在 ${Math.round(downTimeout / 1000)}s 内优雅退出，已强制终止；`
+        + (targetKind === 'codex' ? 'resume 的会话可能不完整' : '会话状态可能不完整');
+      try { execSync(`${tmux} send-keys -t "${session}" C-c`, EXEC_OPTS); } catch {}
+      await sleep(2000);
+      if (detectKind(session, socketPath) === targetKind) {
+        try {
+          const panePid = execSync(
+            `${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS
+          ).trim();
+          execSync(`pkill -KILL -P ${panePid} 2>/dev/null || true`, EXEC_OPTS);
+        } catch {}
+        await sleep(2000);
+      }
+      break;
+    }
     await sleep(1000);
   }
-  await sleep(500); // 等 shell prompt 落定
-  // 起 + poll-up（30s）
+
+  // 3. 等 shell prompt 落定
+  await sleep(500);
+
+  // 4-5. 起 + poll-up（30s）+ 5s 存活复检
   const tryStart = async () => {
     try {
       execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(startCmd)}`, EXEC_OPTS);
@@ -174,21 +241,33 @@ async function restartSkeleton(session, socketPath, { targetKind, stopAction, do
       if (Date.now() >= upDeadline) return false;
       await sleep(1000);
     }
-    return true;
+    // 存活复检：起来后等 5s 再确认还在（codex 启动可能撞自更新菜单、随即自退）
+    await sleep(5000);
+    return detectKind(session, socketPath) === targetKind;
   };
-  if (await tryStart()) return true;
-  // 没起来：C-c 清掉可能的半行，重试一次
+
+  if (await tryStart()) return { ok: true, warning, startCmd };
+
+  // 6. 没起来 / 起来又随即退：C-c 清半行后重试一次
   try { execSync(`${tmux} send-keys -t "${session}" C-c`, EXEC_OPTS); } catch {}
   await sleep(500);
-  return tryStart();
+  if (await tryStart()) return { ok: true, warning, startCmd };
+
+  return {
+    ok: false,
+    startCmd,
+    warning: warning
+      || `${targetKind} 启动后未稳定存活（可能启动时撞自更新随即退出），请 seam term read 确认`,
+  };
 }
 
 /**
  * 重启 session 里跑的东西。只对 cc / codex 有意义——非 cc/codex（shell 或
  * 自定义命令）直接报错，不静默重启成 bash。
  *
- * cc：优雅 /exit（跑 Stop hook，120s 超时覆盖 auto-save/semantic_memory）。
- * codex：kill 进程（30s 短超时）。两者都轮询确认停了再起。
+ * cc 与 codex 都走对称的优雅路径（发 exit 命令 → 轮询退出 → 续命命令重起），
+ * 差别（退出命令 / 超时 / 续命命令）全在 KIND_CMD 表里。
+ * 返回 { ok, warning }。
  */
 async function restartTerm(session, { socketPath, continueSession = true } = {}) {
   const tmux = tmuxCmd(socketPath);
@@ -199,38 +278,21 @@ async function restartTerm(session, { socketPath, continueSession = true } = {})
       + 'restart 不知道该用什么命令重启它。要重起请用 `seam term start --kind ... --cmd "..."`。'
     );
   }
-  if (kind === 'cc') {
-    const startCmd = continueSession ? `${KIND_CMD.cc} --continue` : KIND_CMD.cc;
-    return restartSkeleton(session, socketPath, {
-      targetKind: 'cc',
-      // cc 必须优雅退：发 /exit 跑 Stop hook，kill 会丢 AI 记忆
-      stopAction: () => {
-        execSync(`${tmux} send-keys -t "${session}" -l '/exit'`, EXEC_OPTS);
-        execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
-      },
-      downTimeout: 120000,
-      startCmd,
-    });
-  }
-  // codex：kill pane 进程的子进程（codex），bash 留着，会话不死
+  const spec = KIND_CMD[kind];
+  const startCmd = continueSession ? spec.resume : spec.fresh;
   return restartSkeleton(session, socketPath, {
-    targetKind: 'codex',
+    targetKind: kind,
     stopAction: () => {
-      try {
-        const panePid = execSync(
-          `${tmux} display-message -t "${session}" -p '#{pane_pid}'`, EXEC_OPTS
-        ).trim();
-        execSync(`pkill -TERM -P ${panePid} 2>/dev/null || true`, EXEC_OPTS);
-      } catch {}
+      execSync(`${tmux} send-keys -t "${session}" -l ${JSON.stringify(spec.exit)}`, EXEC_OPTS);
+      execSync(`${tmux} send-keys -t "${session}" Enter`, EXEC_OPTS);
     },
-    downTimeout: 30000,
-    startCmd: KIND_CMD.codex,
+    downTimeout: spec.downTimeout,
+    startCmd,
   });
 }
 
 /**
- * 关掉整个终端（kill-session）。返回关之前检测到的 kind（供调用方判断是否
- * 连带杀了 guardian）。
+ * 关掉整个终端（kill-session）。返回关之前检测到的 kind。
  */
 function stopTerm(session, { socketPath } = {}) {
   const tmux = tmuxCmd(socketPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seamnet/client",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "description": "One command to join Seam — the network where people and AI stay in sync.",
   "bin": {
     "seam-client": "bin/cli.js",