cron-up 26.10.31 → 26.10.33

package/src/registry.mjs

@@ -62,18 +62,18 @@ export function processParentMap() {
   return map.size > 0 ? map : null;
 }
 
-// 沿父子表上溯（不含 pid 自身），直到 launchd(1；其父记为 0)。中途父 pid
-// 在快照里缺失（ps 退化/进程刚好退出）或成环时 chainComplete=false。
+// 沿父子表上溯（不含 pid 自身），直到 launchd(1；其父记为 0)、父 pid 在
+// 快照里缺失或成环。调用方只消费祖先列表；断链时保留已读到的部分即可。
 export function ancestorChain(pid, parentMap) {
   const ancestors = [];
   const seen = new Set([pid]);
   let cur = pid;
   for (;;) {
     const parent = parentMap?.get(cur);
-    if (parent === undefined) return { ancestors, chainComplete: false };
+    if (parent === undefined) return ancestors;
     ancestors.push(parent);
-    if (parent <= 1) return { ancestors, chainComplete: true }; // 0/1 即根
-    if (seen.has(parent)) return { ancestors, chainComplete: false };
+    if (parent <= 1) return ancestors; // 0/1 即根
+    if (seen.has(parent)) return ancestors;
     seen.add(parent);
     cur = parent;
   }
@@ -159,9 +159,9 @@ async function readSessionFile(file) {
 }
 
 // 返回 [拥有活消费者会话的工作区集合, 告警字符串|null, 会话详情 Map]。
-// 第三个元素是 Map<cwd, Array<{pid, sessionId, procStart, ancestors,
-// chainComplete}>>。祖先链恒拍：快照失败给空链，相关预热本轮认不到亲、
-// 下轮自动重试；consumers 判定不受影响。
+// 第三个元素是 Map<cwd, Array<{pid, sessionId, procStart, ancestors}>>。
+// 祖先链恒拍：快照失败给空链，相关预热本轮认不到亲、下轮自动重试；
+// consumers 判定不受影响。
 export async function scanSessions() {
   let files = [];
   try {
@@ -217,9 +217,7 @@ export async function scanSessions() {
       if (typeof cwd === 'string' && path.isAbsolute(cwd)) {
         const ws = lexReal(cwd);
         consumers.add(ws);
-        const chain = parentMap
-          ? ancestorChain(pid, parentMap)
-          : { ancestors: [], chainComplete: false };
+        const ancestors = parentMap ? ancestorChain(pid, parentMap) : [];
         const list = details.get(ws) ?? [];
         list.push({
           pid,
@@ -227,8 +225,7 @@ export async function scanSessions() {
           // procStart 是 ps lstart 原文（单位数日期含双空格），只许原样
           // 传递给任务文件，绝不能自己拼。
           procStart: typeof s.procStart === 'string' ? s.procStart : null,
-          ancestors: chain.ancestors,
-          chainComplete: chain.chainComplete,
+          ancestors,
         });
         details.set(ws, list);
         continue;

package/src/service.mjs

@@ -22,34 +22,52 @@ import {
   validateConfig,
   normalizeRoots,
 } from './config.mjs';
-import { scriptProcLogPath } from './sessions.mjs';
+import { scriptProcLogPath, shellQuote } from './sessions.mjs';
 
 function guiTarget() {
   return `gui/${process.getuid()}`;
 }
 
 // launchctl 调用统一走不抛的 execFile，判成败看 status。与 ps 同款防御：
-// launchctl 卡住时命令挂死不如超时报「未加载」——总览页至少还能出来。
+// launchctl 卡住时命令挂死不如超时报「未加载」——总览页至少还能出来；卸载
+// 等破坏性操作另用下方三态 probe，状态未知时拒绝继续。
 export function launchctl(...args) {
   return deps.execFile('/bin/launchctl', args, { timeout: 10000 });
 }
 
-export function launchctlInfo() {
-  // 走 deps 而非同文件裸名：与 bootout/bootstrap 的打桩面保持一致，测试可
-  // 在 launchctl 一层整体模拟 launchd。
-  const r = deps.launchctl('print', `${guiTarget()}/${LABEL}`);
-  if (r.status !== 0) return null;
+function parseLaunchctlInfo(stdout = '') {
   const info = {};
   for (const key of ['state', 'last exit code']) {
-    const m = r.stdout.match(
+    const m = stdout.match(
       new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=\\s*(.+)$`, 'm'));
     if (m) info[key] = m[1].trim();
   }
-  const iv = r.stdout.match(/^\s*run interval\s*=\s*(\d+)\s*seconds/m);
+  const iv = stdout.match(/^\s*run interval\s*=\s*(\d+)\s*seconds/m);
   if (iv) info.interval = parseInt(iv[1], 10);
   return info;
 }
 
+// 卸载需要比 info/null 更细的结论：launchctl 对未加载与查询失败都返回非零，
+// 只有明确的「找不到服务」才能安全继续删除安装产物。
+function launchctlProbe() {
+  const r = deps.launchctl('print', `${guiTarget()}/${LABEL}`);
+  if (r.status === 0) {
+    return { kind: 'loaded', info: parseLaunchctlInfo(r.stdout ?? '') };
+  }
+  const stderr = (r.stderr ?? '').trim();
+  if (/could not find service/i.test(stderr)) return { kind: 'unloaded' };
+  return {
+    kind: 'unknown',
+    message: stderr || `launchctl print 退出码 ${r.status ?? '未知'}`,
+  };
+}
+
+export function launchctlInfo() {
+  // 总览页继续只看 info/null；详细三分状态仅供卸载等破坏性操作使用。
+  const probe = launchctlProbe();
+  return probe.kind === 'loaded' ? probe.info : null;
+}
+
 const LAUNCHD_STATES = new Map([
   ['running', '运行中'],
   ['not running', '空闲中（按间隔触发）'],
@@ -90,14 +108,17 @@ function isExecutable(p) {
 }
 
 // 返回 {pathDirs}：启动脚本要写进 PATH 的 bin 目录。注入 home/execPath/
-// systemPaths 仅为测试在临时 HOME 里伪造各安装形态。fnm 的
+// cronUpPath/systemPaths 仅为测试在临时 HOME 里伪造各安装形态。fnm 的
 // aliases/default/bin 是跟随 `fnm default` 切换的稳定 symlink（切勿
 // realpath 到版本化目录，fnm 升级后那里会失效）；volta 的 ~/.volta/bin、
 // Homebrew 与官网 pkg 的系统 bin 同理是版本无关的稳定入口。都不认识时退
-// 回当前安装进程自己的 bin 目录：nvm 等按版本目录安装的形态由此覆盖。
+// 回当前安装进程自己的 node bin 目录：nvm 等按版本目录安装的形态由此覆盖。
+// node 目录与当前实际 cron-up 的 bin 目录都必须保留：fnm 非默认版本、nvm
+// 或独立 npm prefix 下两者经常不同，找到稳定 node 后提前返回会丢掉 cron-up。
 export function resolveLauncher(opts = {}) {
   const home = opts.home ?? paths.home;
   const execPath = opts.execPath ?? process.execPath;
+  const cronUpPath = opts.cronUpPath ?? process.argv[1];
   const systemPaths = opts.systemPaths
     ?? ['/opt/homebrew/bin/node', '/usr/local/bin/node'];
 
@@ -111,14 +132,19 @@ export function resolveLauncher(opts = {}) {
     path.join(home, '.volta', 'bin'),
     ...systemPaths.map((p) => path.dirname(p)),
   ];
-  for (const dir of candidates) {
-    if (isExecutable(path.join(dir, 'node'))) return { pathDirs: [dir] };
+  const stableNodeDir = candidates.find((dir) => isExecutable(path.join(dir, 'node')));
+  const nodeDir = stableNodeDir ?? path.dirname(execPath);
+  // argv[1] 保留 npm 全局 bin symlink 的调用路径；不要 realpath 到包内
+  // bin/cron-up.mjs，否则独立 npm prefix 的 shim 目录会丢。无 argv[1] 时
+  // 退回 node 目录，至少覆盖 node 与全局 bin 同目录的常见安装。
+  const cronUpDir = cronUpPath
+    ? path.dirname(path.resolve(cronUpPath)) : path.dirname(execPath);
+  const result = { pathDirs: [...new Set([nodeDir, cronUpDir])] };
+  if (stableNodeDir === undefined) {
+    result.note = '未能定位版本无关的 node bin 目录，已使用当前 node 所在目录；'
+      + '该目录失效（如版本目录被删）时请重新运行 cron-up install';
   }
-  return {
-    pathDirs: [path.dirname(execPath)],
-    note: '未能定位版本无关的 node bin 目录，已使用当前 node 所在目录；'
-      + '该目录失效（如版本目录被删）时请重新运行 cron-up install',
-  };
+  return result;
 }
 
 // ---- plist ----
@@ -145,7 +171,9 @@ function xmlUnescape(s) {
 export function writeServiceScript(launcher) {
   const script = deps.paths.serviceScriptPath;
   fs.mkdirSync(path.dirname(script), { recursive: true });
-  const dirs = launcher.pathDirs.map((d) => `"${d}"`).join(':');
+  // 整个冒号前缀作为一个 shell word 引用：健康检查可无损解回同一串目录，
+  // 空格、单双引号、$ 等字符不会变成 shell 语法。
+  const dirs = shellQuote(launcher.pathDirs.join(':'));
   fs.writeFileSync(script,
     '#!/bin/bash\n'
     + '# 由 cron-up install 生成；重跑 cron-up install 覆盖重生成\n'
@@ -197,6 +225,51 @@ export function readPlistProgramArgs() {
   return parts.length > 0 ? parts : null;
 }
 
+// 解一个 POSIX shell word（不执行它）。覆盖 shellQuote 生成的单引号与
+// '"'"' 拼接，也兼容旧版脚本简单的双引号目录；含未引用空白、命令替换或
+// 变量展开的手改内容拒绝猜测。
+function parseShellWord(source) {
+  let value = '';
+  for (let i = 0; i < source.length;) {
+    const ch = source[i];
+    if (ch === "'") {
+      const end = source.indexOf("'", i + 1);
+      if (end < 0) return null;
+      value += source.slice(i + 1, end);
+      i = end + 1;
+      continue;
+    }
+    if (ch === '"') {
+      i += 1;
+      let closed = false;
+      while (i < source.length) {
+        if (source[i] === '"') {
+          closed = true;
+          i += 1;
+          break;
+        }
+        if (source[i] === '$' || source[i] === '`') return null;
+        if (source[i] === '\\') {
+          if (i + 1 >= source.length) return null;
+          i += 1;
+        }
+        value += source[i];
+        i += 1;
+      }
+      if (!closed) return null;
+      continue;
+    }
+    if (/\s/.test(ch) || /[$`;&|<>()]/.test(ch)) return null;
+    if (ch === '\\') {
+      if (i + 1 >= source.length) return null;
+      i += 1;
+    }
+    value += source[i];
+    i += 1;
+  }
+  return value;
+}
+
 // 从启动脚本内容里解出 PATH 目录；脚本是我们生成的固定格式，解不出（手改
 // 坏）返回 null。
 function scriptPathDirs(scriptPath) {
@@ -207,7 +280,11 @@ function scriptPathDirs(scriptPath) {
     return null;
   }
   const m = text.match(/^export PATH=(.+):"\$PATH"$/m);
-  return m ? m[1].split('":"').map((s) => s.replace(/"/g, '')) : null;
+  if (!m) return null;
+  const prefix = parseShellWord(m[1]);
+  if (!prefix) return null;
+  const dirs = prefix.split(':');
+  return dirs.every(Boolean) ? dirs : null;
 }
 
 // 总览页健康检查：launchd 每轮按启动脚本拉起巡检，脚本丢失、被手改或
@@ -290,20 +367,37 @@ export async function cmdInstall(args) {
       + '--roots 指定（见 README 安全说明）');
   }
 
-  const launcher = resolveLauncher();
+  const launcher = deps.resolveLauncher();
   if (launcher.note) deps.print(`提示：${launcher.note}`);
 
   const script = writeServiceScript(launcher);
+  fs.mkdirSync(path.dirname(deps.paths.plistPath), { recursive: true });
   fs.writeFileSync(deps.paths.plistPath, renderPlist(script));
   deps.print(`已写入启动脚本与 LaunchAgent：${script}、${deps.paths.plistPath}`);
 
+  // bootstrap 成功只代表 launchd 收下 plist，不代表脚本真能解析 node 与
+  // cron-up。先自检启动链，避免随后的手动首轮巡检掩盖坏脚本。
+  const health = launcherHealth();
+  if (health) {
+    deps.printErr(`启动链自检失败：${health}`);
+    throw new ExitError(1);
+  }
+
   deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
   const r = deps.launchctl('bootstrap', guiTarget(), deps.paths.plistPath);
   if (r.status !== 0) {
     deps.printErr(`加载到 launchd 失败：\n${r.stderr.trim()}`);
     throw new ExitError(1);
   }
-  deps.launchctl('enable', `${guiTarget()}/${LABEL}`);
+  const enabled = deps.launchctl('enable', `${guiTarget()}/${LABEL}`);
+  if (enabled.status !== 0) {
+    deps.printErr(`启用 launchd 服务失败：\n${enabled.stderr.trim()}`);
+    throw new ExitError(1);
+  }
+  if (deps.launchctlInfo() === null) {
+    deps.printErr('加载后未能向 launchd 核实服务状态，请检查 cron-up 与 launchctl');
+    throw new ExitError(1);
+  }
   deps.print('已加载到 launchd');
 
   // install 与巡检撞车时首轮会被跳过，不能照常说「完成」。
@@ -353,34 +447,79 @@ export async function cmdUninstall(args) {
     throw new ExitError(2, 'uninstall 不支持 --config：卸载操作的是本机固定'
       + `的安装产物（${deps.paths.plistPath} 等）`);
   }
-  const r = deps.launchctl('bootout', `${guiTarget()}/${LABEL}`);
-  if (r.status === 0) deps.print('已从 launchd 卸载');
-
-  // 服务没了就没有回收者：默认结束全部预热会话，不留以 bypass 权限空转
-  // 的孤儿。各会话的停轮询（SIGTERM→等→SIGKILL）互不依赖，先逐个发信
-  // 号再并行等齐。
-  const stopping = [];
-  for (const { label, ent } of allTrackedWarmups()) {
-    deps.print(`正在结束预热会话 ${label}`);
-    stopping.push(deps.stopSession(ent));
+  const lock = deps.acquireRunLock();
+  if (lock === null) {
+    deps.printErr('已有一轮巡检在进行，为避免误删正在使用的产物，本次不卸载；'
+      + '请稍后重试');
+    throw new ExitError(1);
   }
-  await Promise.all(stopping);
+  try {
+    const target = `${guiTarget()}/${LABEL}`;
+    const before = deps.launchctlProbe();
+    if (before.kind === 'unknown') {
+      deps.printErr(`无法确认 launchd 服务状态：${before.message}\n`
+        + '状态未知时不能安全卸载，本次不删除 LaunchAgent、配置或日志');
+      throw new ExitError(1);
+    }
+    if (before.kind === 'unloaded') {
+      deps.print('launchd 服务未加载，无需重复卸载');
+    } else {
+      const r = deps.launchctl('bootout', target);
+      if (r.status !== 0) {
+        deps.printErr(`从 launchd 卸载失败：\n${r.stderr.trim()}\n`
+          + '为避免留下无人回收的预热会话，本次不删除 LaunchAgent、配置或日志');
+        throw new ExitError(1);
+      }
+      const after = deps.launchctlProbe();
+      if (after.kind === 'unknown') {
+        deps.printErr(`bootout 后无法确认 launchd 服务状态：${after.message}\n`
+          + '本次不继续删除 LaunchAgent、配置或日志');
+        throw new ExitError(1);
+      }
+      if (after.kind === 'loaded') {
+        deps.printErr('launchctl bootout 已返回，但服务仍能查到；本次不继续清理');
+        throw new ExitError(1);
+      }
+      deps.print('已从 launchd 卸载');
+    }
 
-  if (fs.existsSync(deps.paths.plistPath)) {
-    fs.rmSync(deps.paths.plistPath, { force: true });
-    deps.print(`已删除 ${deps.paths.plistPath}`);
-  }
+    // 服务没了就没有回收者：默认结束全部预热会话，不留以 bypass 权限空转
+    // 的孤儿。各会话的停轮询（SIGTERM→等→SIGKILL）互不依赖，先逐个发信
+    // 号再并行等齐。
+    const stopping = [];
+    for (const { label, ent } of allTrackedWarmups()) {
+      deps.print(`正在结束预热会话 ${label}`);
+      stopping.push(deps.stopSession(ent).then(
+        (stopped) => stopped ? null : label,
+      ));
+    }
+    const unsafe = (await Promise.all(stopping))
+      .filter((label) => label !== null);
+    if (unsafe.length > 0) {
+      deps.printErr('警告：以下预热会话仍活着，本次无法安全停止：'
+        + `${unsafe.join('、')}。已中止后续清理，`
+        + '不会继续删除 LaunchAgent、配置或日志；请人工核对后重试');
+      throw new ExitError(1);
+    }
 
-  if (args.purge) {
-    for (const p of [deps.paths.dataDir, deps.paths.logDir]) {
-      fs.rmSync(p, { recursive: true, force: true });
-      deps.print(`已删除 ${p}`);
+    if (fs.existsSync(deps.paths.plistPath)) {
+      fs.rmSync(deps.paths.plistPath, { force: true });
+      deps.print(`已删除 ${deps.paths.plistPath}`);
     }
-    // npm 管的文件不能手删：命令行本身交给 npm 卸载。
-    deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
-  } else {
-    deps.print('配置与日志已保留（--purge 可删除全部产物）');
+
+    if (args.purge) {
+      for (const p of [deps.paths.dataDir, deps.paths.logDir]) {
+        fs.rmSync(p, { recursive: true, force: true });
+        deps.print(`已删除 ${p}`);
+      }
+      // npm 管的文件不能手删：命令行本身交给 npm 卸载。
+      deps.print('命令行本身请运行 npm uninstall -g cron-up 卸载');
+    } else {
+      deps.print('配置与日志已保留（--purge 可删除全部产物）');
+    }
+  } finally {
+    deps.releaseRunLock(lock);
   }
 }
 
-Object.assign(deps, { launchctl, launchctlInfo });
+Object.assign(deps, { launchctl, launchctlInfo, launchctlProbe, resolveLauncher });

package/src/sessions.mjs

@@ -81,7 +81,8 @@ export function sessionArgv(ws, logPath) {
   // 里靠继承现成 PATH 一切正常，交给 launchd 就 fnm: command not found。
   return [
     '/usr/bin/script', '-q', logPath,
-    '/bin/zsh', '-lic', `cd ${shellQuote(ws)} && claude`,
+    '/bin/zsh', '-lic',
+    `cd ${shellQuote(ws)} && claude --permission-mode bypassPermissions`,
   ];
 }
 
@@ -109,6 +110,12 @@ export function rotateOnce(file) {
   fs.renameSync(file, old);
 }
 
+// 进程组信号只接受明确大于 1 的整数 pid：0/-1 等有广播含义，浮点、
+// 负数或非安全整数也都不能交给 process.kill。
+function canSignalProcessGroup(pid) {
+  return Number.isSafeInteger(pid) && pid > 1;
+}
+
 // 为一个任务拉起一个 detached 的 pty TUI，返回 {pid, procStart}。
 export function spawnSession(ws, taskId) {
   const logPath = sessionLogPath(ws, taskId);
@@ -149,34 +156,68 @@ export function spawnSession(ws, taskId) {
   // 拉不起来（spawn 当场失败，pid 是 undefined）时返回 null：没有进程可跟
   // 踪，调用方按启动失败计数，不把 pid=undefined 写进 state。
   if (child.pid === undefined) return null;
-  return { pid: child.pid, procStart: deps.procStartedAt(child.pid) };
+  let procStart = null;
+  let fingerprintError = null;
+  try {
+    procStart = deps.procStartedAt(child.pid);
+  } catch (e) {
+    fingerprintError = e;
+  }
+  if (procStart) return { pid: child.pid, procStart };
+
+  // 没有指纹的条目今后无法安全发信号，不能登记成正常会话。这里只清理
+  // 刚刚由本次 spawn 创建的进程组；pid 形状异常时宁可留下日志也不冒险。
+  const reason = fingerprintError
+    ? `读取进程身份指纹失败：${fingerprintError?.message ?? fingerprintError}`
+    : '未读到进程身份指纹';
+  let cleanup;
+  if (canSignalProcessGroup(child.pid)) {
+    try {
+      process.kill(-child.pid, 'SIGTERM');
+      cleanup = '已向刚拉起的进程组发送 SIGTERM';
+    } catch (e) {
+      cleanup = `清理刚拉起的进程组失败：${e?.code ? `${e.code}：` : ''}`
+        + `${e?.message ?? e}`;
+    }
+  } else {
+    cleanup = 'pid 不是大于 1 的整数，未发信号';
+  }
+  deps.log(`会话启动失败 ${ws} 任务 ${taskId} pid=${child.pid}：${reason}；`
+    + cleanup);
+  return null;
 }
 
 // 按进程组结束我们拉起的会话。发信号前先核身份：state 条目可能比它命名
 // 的进程活得久，给回收 pid 发组信号会杀掉无关进程组。detached（用户
-// resume 接管）时 trackedAlive 为 false：本函数直接返回，绝不碰用户的裸
-// claude。
+// resume 接管）时 trackedAlive 为 false：本函数返回 true，绝不碰用户的裸
+// claude。false 表示记录的进程仍活着，但因缺少指纹或信号失败而未能安全
+// 停止；调用方必须保留跟踪并告警，不能假装已经回收。
 export async function stopSession(ent) {
-  if (!deps.trackedAlive(ent)) return;
-  const pid = ent.pid;
+  const pid = ent?.pid;
+  if (!canSignalProcessGroup(pid)) return true;
+  if (!deps.trackedAlive(ent)) return true;
+  // trackedAlive 为兼容旧条目会在没有 procStart 时退回 kill -0；读取可以
+  // 沿用这个判断，停止却不行。死进程无需处理，活进程只能如实报告未停止。
+  if (!ent.procStart) return deps.alive(pid) ? false : true;
   try {
     process.kill(-pid, 'SIGTERM');
   } catch {
-    return;
+    return deps.alive(pid) ? false : true;
   }
   for (let i = 0; i < 20; i++) {
     await deps.sleep(100);
-    if (!deps.alive(pid)) return;
+    if (!deps.alive(pid)) return true;
   }
-  // 升级 SIGKILL 前再核一次指纹。
-  if (deps.trackedAlive(ent)) {
-    try {
-      process.kill(-pid, 'SIGKILL');
-    } catch {
-      // 组已消失。
-    }
-    await deps.sleep(100);
+  if (!deps.trackedAlive(ent)) return true;
+  // 升级 SIGKILL 前已再核一次指纹；信号失败或结束后仍是同一进程，都不能
+  // 向调用方报告停止成功。
+  try {
+    process.kill(-pid, 'SIGKILL');
+  } catch {
+    return deps.alive(pid) ? false : true;
   }
+  await deps.sleep(100);
+  return deps.trackedAlive(ent) ? false : true;
 }
 
 // typescript 多少秒没被写。文件缺失读作「没有任何活动证据」：Infinity 大