@lark-codem/codem-cli 0.1.270 → 0.1.271-early-build-dev.100103738101.0.g5243898

package/bin/process-tree.js

@@ -0,0 +1,217 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { applyHostedWindowsChildOptions } from "./platform-child-process.js";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * 进程树终止。
+ *
+ * 为什么不能只 `child.kill()`：我们 spawn 的是 linco 一个进程，但 linco 干活时
+ * 会自己再起子进程（内联的 `npm run dev`、`cargo build`、git…）。只杀直接子进程
+ * 会把整棵子树留成孤儿——它们继续占端口、占锁，而且**继承了我们的 stdio 管道**,
+ * 于是 `child` 的 `close` 永远不触发（见 linco-runner.js 的
+ * LINCO_EXIT_DRAIN_GRACE_MS）。
+ *
+ * 为什么必须"先快照后代、再杀"：`ps` 反查 ppid（unix）和 `taskkill /T`
+ * （Windows）**都依赖父进程还活着**。父进程一死，后代立刻被 reparent 到 PID 1
+ * （Windows 上 ppid 指向一个已消失的 pid），血缘信息就永久丢了，再也认不出哪些
+ * 进程曾属于这次 run。而"父死子活"恰恰就是我们要处理的那个场景。所以血缘必须
+ * 在**树还完整的时刻**取样，强杀阶段只按快照执行。
+ */
+
+// `ps -A -o pid=,ppid=` 是 POSIX 通用形态，macOS / Linux 输出一致（两列数字,
+// 前导空格对齐）。用 `=` 后缀去掉表头，省一次解析分支。
+const UNIX_PS_ARGS = ["-A", "-o", "pid=,ppid="];
+
+// Win32 没有 POSIX ps。PowerShell 的 CIM 查询比已废弃的 wmic 稳（wmic 在
+// Windows 11 / Server 2025 上默认不再安装）。输出两列数字，与 unix 分支同构。
+const WINDOWS_PS_ARGS = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-Command",
+  "Get-CimInstance Win32_Process | ForEach-Object { \"$($_.ProcessId) $($_.ParentProcessId)\" }"
+];
+
+function parsePidPairs(stdout) {
+  const pairs = [];
+  for (const line of String(stdout ?? "").split("\n")) {
+    const match = line.trim().match(/^(\d+)\s+(\d+)$/);
+    if (!match) {
+      continue;
+    }
+    pairs.push([Number.parseInt(match[1], 10), Number.parseInt(match[2], 10)]);
+  }
+  return pairs;
+}
+
+/**
+ * 广度优先收集 rootPid 的全部后代（不含 rootPid 自己），返回**由深到浅**的顺序。
+ *
+ * 由深到浅是为了终止时先杀叶子：先杀中间节点会让它的孩子提前变孤儿，剩下的
+ * kill 就打空了。
+ *
+ * 任何失败都返回空数组——快照是尽力而为的增强，绝不能让它把调用方的终止路径
+ * 拖崩。拿不到血缘时调用方仍会杀直接子进程，等于退回改动前的行为。
+ */
+export async function snapshotDescendantPids(
+  rootPid,
+  { platform = process.platform, execFileImpl = execFileAsync, timeoutMs = null, onError = null } = {}
+) {
+  if (!Number.isInteger(rootPid) || rootPid <= 0) {
+    return [];
+  }
+
+  const startedAt = performance.now();
+  let pairs = [];
+  try {
+    const { stdout } =
+      platform === "win32"
+        ? await execFileImpl(
+            "powershell.exe",
+            WINDOWS_PS_ARGS,
+            applyHostedWindowsChildOptions(
+              Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeout: timeoutMs } : {},
+              { platform }
+            )
+          )
+        : await execFileImpl(
+            "ps",
+            UNIX_PS_ARGS,
+            applyHostedWindowsChildOptions(
+              Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeout: timeoutMs } : {},
+              { platform }
+            )
+          );
+    pairs = parsePidPairs(stdout);
+  } catch (error) {
+    onError?.(error, {
+      durationMs: Math.round(performance.now() - startedAt),
+      timeoutMs,
+      code: error?.code ?? null,
+      killed: error?.killed === true,
+      signal: error?.signal ?? null
+    });
+    return [];
+  }
+
+  const childrenByParent = new Map();
+  for (const [pid, ppid] of pairs) {
+    if (pid === ppid) {
+      // 自指（部分系统上 pid 1 会这么报）。放任会让下面的 BFS 死循环。
+      continue;
+    }
+    const bucket = childrenByParent.get(ppid);
+    if (bucket) {
+      bucket.push(pid);
+    } else {
+      childrenByParent.set(ppid, [pid]);
+    }
+  }
+
+  const levels = [];
+  const seen = new Set([rootPid]);
+  let frontier = [rootPid];
+  // 深度上限：纯防御。真实进程树不会有 64 层，但快照来自外部命令的文本输出,
+  // 一旦解析出环就会在这里无限打转。
+  for (let depth = 0; depth < 64 && frontier.length > 0; depth += 1) {
+    const next = [];
+    for (const pid of frontier) {
+      for (const childPid of childrenByParent.get(pid) ?? []) {
+        if (seen.has(childPid)) {
+          continue;
+        }
+        seen.add(childPid);
+        next.push(childPid);
+      }
+    }
+    if (next.length > 0) {
+      levels.push(next);
+    }
+    frontier = next;
+  }
+
+  return levels.reverse().flat();
+}
+
+/**
+ * 杀掉 rootPid 及其后代。
+ *
+ * `descendants` 由调用方在树还完整时用 snapshotDescendantPids 取样后传入；
+ * 不传就现取（只在父进程仍活着时才有意义）。
+ *
+ * 返回实际发出信号的 pid 数——调用方用它做日志，不做控制流：kill 失败绝大多数
+ * 是"进程已经没了"，那正是我们要的结果。
+ */
+export async function terminateProcessTree({
+  pid,
+  descendants = null,
+  signal = "SIGKILL",
+  platform = process.platform,
+  execFileImpl = execFileAsync,
+  killImpl = (targetPid, targetSignal) => process.kill(targetPid, targetSignal),
+  timeoutMs = null,
+  onError = null
+} = {}) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return { signaled: 0 };
+  }
+
+  const targets =
+    descendants ??
+    (await snapshotDescendantPids(pid, { platform, execFileImpl, timeoutMs, onError }));
+  let signaled = 0;
+
+  if (platform === "win32") {
+    // /T 覆盖此刻仍挂在 pid 下的活树，一次调用比逐个 taskkill 更少竞态。
+    try {
+      await execFileImpl(
+        "taskkill.exe",
+        ["/F", "/T", "/PID", String(pid)],
+        applyHostedWindowsChildOptions(
+          Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeout: timeoutMs } : {},
+          { platform }
+        )
+      );
+      signaled += 1;
+    } catch (error) {
+      // pid 已消失时 taskkill 返回非 0，属预期。
+      onError?.(error);
+    }
+    // 快照里那些已经和 pid 断了血缘的（父先死的孤儿），/T 够不着，逐个补刀。
+    for (const targetPid of targets) {
+      try {
+        await execFileImpl(
+          "taskkill.exe",
+          ["/F", "/PID", String(targetPid)],
+          applyHostedWindowsChildOptions(
+            Number.isFinite(timeoutMs) && timeoutMs > 0 ? { timeout: timeoutMs } : {},
+            { platform }
+          )
+        );
+        signaled += 1;
+      } catch {
+        // 已退出。
+      }
+    }
+    return { signaled };
+  }
+
+  // unix：叶子优先，最后才是 root。
+  for (const targetPid of targets) {
+    try {
+      killImpl(targetPid, signal);
+      signaled += 1;
+    } catch {
+      // 已退出。
+    }
+  }
+  try {
+    killImpl(pid, signal);
+    signaled += 1;
+  } catch {
+    // 已退出。
+  }
+  return { signaled };
+}

package/bin/worker-runtime.js

@@ -1,6 +1,7 @@
 // Startup-only routing. Keep this module independent of Bridge business imports:
 // it is also executed by container entrypoints before either Bridge is loaded.
-import { spawn } from 'node:child_process';
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
 import { createHash, randomUUID } from 'node:crypto';
 import fs from 'node:fs/promises';
 import { constants as fsConstants } from 'node:fs';
@@ -11,6 +12,9 @@ import { setTimeout as delay } from 'node:timers/promises';
 import { applyHostedWindowsChildOptions } from './platform-child-process.js';
 import { resolveEffectiveLincoHome, resolveLincoSessionsRoot, sameRecoveryPath } from './linco-paths.js';
 import { observeWorkerRuntime } from './worker-runtime-telemetry.js';
+import { snapshotDescendantPids, terminateProcessTree } from './process-tree.js';
+
+const execFileAsync = promisify(execFile);
 
 export const WORKER_HOST_HOME = process.env.CODEM_WORKER_HOST_HOME || path.join(os.homedir(), '.codem');
 export const WORKER_RUNTIME_ROOT = path.join(WORKER_HOST_HOME, 'worker-runtimes');
@@ -271,11 +275,58 @@ export function launchWorkerRuntime(runtime, { args = process.argv.slice(2), env
    CODEM_SKIP_UPDATE_CHECK: '1', CODEM_DISABLE_DAEMON_AUTO_UPDATE: '1' } }));
   const stopObservation=observeWorkerRuntime(runtime,{env,args});
   const signals = ['SIGTERM', 'SIGINT', 'SIGHUP'];
-  const handlers = signals.map(signal => () => { if (child.exitCode === null && child.signalCode === null) { try { child.kill(signal); } catch {} } });
+  let shutdownTimer = null, descendants = null, shutdownCleanup = null;
+  const cleanup = () => {clearTimeout(shutdownTimer);stopObservation();signals.forEach((signal, index) => process.off(signal, handlers[index]));};
+  // Both the deadline and an early daemon exit own the same bounded tree cleanup.
+  // In particular, exit must not discard descendants orphaned by graceful shutdown.
+  const finishShutdown = () => {
+   if (shutdownCleanup === null) shutdownCleanup = (async () => {
+    clearTimeout(shutdownTimer);
+    let killTimer;
+    const controller = new AbortController();
+    const execFileImpl = (file, args, options) => execFileAsync(file, args, { ...options, signal: controller.signal });
+    try {
+     await Promise.race([
+      (async () => {
+       const current = child.exitCode === null && child.signalCode === null
+        ? await snapshotDescendantPids(child.pid, { timeoutMs: 1000, execFileImpl }) : [];
+       await terminateProcessTree({ pid: child.pid,
+        descendants: [...new Set([...current, ...await descendants])], timeoutMs: 1000, execFileImpl });
+      })(),
+      new Promise(resolve => { killTimer = setTimeout(resolve, 2000); })
+     ]);
+    } finally {
+     controller.abort();
+     clearTimeout(killTimer);
+     if (child.exitCode === null && child.signalCode === null) { try { child.kill('SIGKILL'); } catch {} }
+     cleanup();
+    }
+   })();
+   return shutdownCleanup;
+  };
+  const handlers = signals.map(signal => () => {
+   if (child.exitCode !== null || child.signalCode !== null || shutdownTimer !== null) return;
+   // Snapshot before forwarding: graceful shutdown may orphan descendants.
+   descendants = snapshotDescendantPids(child.pid, { timeoutMs: 1000 });
+   const exitCode = 128 + (os.constants.signals[signal] || 1);
+   // Sandbox shutdown owns up to 15s plus finalization. Leave that budget intact;
+   // repeated signals cannot renew this independent launcher backstop.
+   shutdownTimer = setTimeout(async () => {
+    await finishShutdown();
+    process.exit(exitCode);
+   }, 20_000);
+   void descendants.then(() => {
+    if (child.exitCode === null && child.signalCode === null) { try { child.kill(signal); } catch {} }
+   });
+  });
   signals.forEach((signal, index) => process.on(signal, handlers[index]));
-  const cleanup = () => {stopObservation();signals.forEach((signal, index) => process.off(signal, handlers[index]));};
   child.once('error', error => { cleanup(); reject(error); });
-  child.once('exit', (code, signal) => { cleanup(); resolve(code ?? (signal ? 128 + (os.constants.signals[signal] || 1) : 1)); });
+  child.once('exit', async (code, signal) => {
+   const exitCode = code ?? (signal ? 128 + (os.constants.signals[signal] || 1) : 1);
+   if (shutdownTimer !== null) await finishShutdown();
+   else cleanup();
+   resolve(exitCode);
+  });
  });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-codem/codem-cli",
-  "version": "0.1.270",
+  "version": "0.1.271-early-build-dev.100103738101.0.g5243898",
   "codemServiceManagementProtocol": 3,
   "codemWorkerRuntimeProtocol": 1,
   "codemProfileProtocol": 1,
@@ -30,17 +30,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@lark-codem/codem-core": "0.8.87",
+    "@lark-codem/codem-core": "0.8.88-early-build-dev.100103738101.0.gc717eeb",
     "zod": "3.25.76",
     "@lark-codem/lark-cli": "0.1.1"
   },
   "optionalDependencies": {
-    "@lark-codem/codem-cli-darwin-arm64": "0.1.270",
-    "@lark-codem/codem-cli-darwin-x64": "0.1.270",
-    "@lark-codem/codem-cli-linux-arm64": "0.1.270",
-    "@lark-codem/codem-cli-linux-x64": "0.1.270",
-    "@lark-codem/codem-cli-win32-arm64": "0.1.270",
-    "@lark-codem/codem-cli-win32-x64": "0.1.270"
+    "@lark-codem/codem-cli-darwin-arm64": "0.1.271-early-build-dev.100103738101.0.g5243898",
+    "@lark-codem/codem-cli-darwin-x64": "0.1.271-early-build-dev.100103738101.0.g5243898",
+    "@lark-codem/codem-cli-linux-arm64": "0.1.271-early-build-dev.100103738101.0.g5243898",
+    "@lark-codem/codem-cli-linux-x64": "0.1.271-early-build-dev.100103738101.0.g5243898",
+    "@lark-codem/codem-cli-win32-arm64": "0.1.271-early-build-dev.100103738101.0.g5243898",
+    "@lark-codem/codem-cli-win32-x64": "0.1.271-early-build-dev.100103738101.0.g5243898"
   },
   "engines": {
     "node": ">=18"