chainlesschain 0.162.174 → 0.162.175

package/src/lazy-dispatch.js

@@ -1,107 +1,108 @@
 /**
- * Lazy CLI dispatch — the cold-start optimization.
- *
- * Importing src/index.js eagerly loads all ~154 command modules + their
- * transitive dependency graph (~2.7s; see memory
- * cli_cold_start_bottleneck_hub_repl). But a real `cc <cmd>` invocation only
- * needs ONE command's module. This dispatcher resolves the target command from
- * argv against the generated manifest (src/command-manifest.json) and imports
- * just that module, then parses.
- *
- * SAFETY: anything uncertain — no command, --help, an unknown command, or a
- * project-mode subcommand whitelist — falls back to the full eager program
- * (src/index.js `createProgram`), i.e. exactly today's behavior. The fast path
- * only activates when a single known command resolves cleanly. Worst case is
- * therefore "as slow as today, still correct", never "wrong".
- *
- * The manifest is regenerated by scripts/gen-command-manifest.mjs and guarded
- * against drift by lazy-dispatch.test.js.
+ * Lazy CLI dispatch - fast path for single commands, full program for help/unknown
  */
-import { readFileSync } from "fs";
-import { createBaseProgram } from "./program-base.js";
-import { maybeNotifyUpdate } from "./lib/update-notice.js";
+import { createProgramAsync } from "./index.js";
+import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
 const manifest = JSON.parse(
-  readFileSync(new URL("./command-manifest.json", import.meta.url), "utf8"),
+  readFileSync(join(__dirname, "command-manifest.json"), "utf8"),
 );
 
-// name + every alias -> manifest entry
-const byName = new Map();
-for (const entry of manifest.commands) {
-  byName.set(entry.name, entry);
-  for (const alias of entry.aliases || []) byName.set(alias, entry);
-}
-
 /**
- * The command token is the first positional arg (the first token that is not a
- * global option). The root program's only global options (--verbose, --quiet)
- * and the -v/--version / -h/--help flags are all boolean and never consume a
- * following value, so "first token not starting with '-'" is unambiguous.
+ * Run the CLI with lazy dispatch optimization
+ * @param {string[]} argv - process.argv
+ * @returns {Promise<void>}
  */
-export function resolveCommandToken(argv) {
-  const rest = argv.slice(2);
-  for (const arg of rest) {
-    if (arg === "--") break;
-    if (arg.startsWith("-")) continue;
-    return arg;
+/** Return the first top-level command token in a process argv array. */
+export function resolveCommandToken(argv = []) {
+  const args = Array.isArray(argv) ? argv.slice(2) : [];
+  for (const token of args) {
+    if (token === "--") return null;
+    if (token === "--verbose" || token === "--quiet") continue;
+    if (["--help", "-h", "--version", "-v", "-V"].includes(token)) return null;
+    if (!token.startsWith("-")) return token;
   }
   return null;
 }
 
-function hasVersionFlag(argv) {
-  return argv.slice(2).some((a) => a === "-v" || a === "--version");
-}
+export async function runCli(argv) {
+  const args = argv.slice(2);
 
-function notify() {
-  // Mirror index.js: passive update nudge, suppressed under vitest.
-  if (!process.env.VITEST) {
-    try {
-      maybeNotifyUpdate();
-    } catch {
-      /* fail-open — never block the CLI on the nudge */
-    }
+  // Resolve the command before deciding whether help/version needs the eager
+  // program. `cc <command> --help` is command-scoped help and must load only
+  // that command; treating every `--help` as root help silently discards the
+  // command token (and broke `cc agent --help` after lazy dispatch landed).
+  const commandName = resolveCommandToken(argv);
+  const entry = manifest.commands.find(
+    (c) =>
+      c.name === commandName || (c.aliases && c.aliases.includes(commandName)),
+  );
+
+  // Fast path: if no args, or --help, or --version, use full program
+  if (
+    args.length === 0 ||
+    (!entry &&
+      (args.includes("--help") ||
+        args.includes("-h") ||
+        args.includes("--version") ||
+        args.includes("-V")))
+  ) {
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
+    return;
   }
-}
 
-/**
- * Parse and run the CLI. Used by the bin entry in place of importing index.js
- * directly (which would defeat lazy loading).
- *
- * @param {string[]} [argv] defaults to process.argv
- * @returns {Promise<import('commander').Command>}
- */
-export async function runCli(argv = process.argv) {
-  // Project-mode packed exes restrict the visible command set; the filtering
-  // lives in the eager createProgram, so defer to it for correctness.
-  const whitelistActive = !!process.env.CC_PROJECT_ALLOWED_SUBCOMMANDS;
-  const token = resolveCommandToken(argv);
+  // Try to find the command in manifest
+  // Unknown command, use full program to show error/help
+  if (!entry) {
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
+    return;
+  }
 
-  // Fast path 1: a known command resolves cleanly.
-  if (token && !whitelistActive && byName.has(token)) {
-    const entry = byName.get(token);
+  // Known command: lazy-load just that command, create minimal program
+  try {
+    const { createBaseProgram } = await import("./program-base.js");
     const program = createBaseProgram();
-    notify();
-    const mod = await import(new URL(entry.module, import.meta.url));
-    const register = mod[entry.register];
-    if (typeof register === "function") {
-      register(program);
-      return program.parseAsync(argv);
+
+    const modulePath = join(__dirname, entry.module.replace("./", ""));
+    const moduleUrl = pathToFileURL(modulePath).href;
+    const mod = await import(moduleUrl);
+    const registerFn = mod[entry.register];
+
+    if (typeof registerFn !== "function") {
+      throw new Error(
+        `Register function '${entry.register}' not found in ${entry.module}`,
+      );
     }
-    // Manifest pointed at a missing export (should be impossible given the
-    // drift test) — fall through to the eager path rather than crash.
-  }
 
-  // Fast path 2: bare version request, no command (base program short-circuits
-  // without loading any command module).
-  if (!token && !whitelistActive && hasVersionFlag(argv)) {
-    const program = createBaseProgram();
-    notify();
-    return program.parseAsync(argv);
+    registerFn(program);
+    await program.parseAsync(argv);
+  } catch (err) {
+    // Fallback to full program on any error
+    if (process.env.DEBUG) {
+      console.warn(
+        "Lazy dispatch failed, falling back to full program:",
+        err.message,
+      );
+    }
+    const program = await createProgramAsync();
+    await program.parseAsync(argv);
   }
+}
 
-  // Fallback: --help, no args, unknown command, or project whitelist — load the
-  // full eager program (today's behavior; createProgram fires its own update
-  // nudge so we do not call notify() here to avoid a double nudge).
-  const { createProgram } = await import("./index.js");
-  return createProgram().parseAsync(argv);
+export class LazyDispatch {
+  constructor(manifest) {
+    this.manifest = manifest;
+  }
+  matches(argv) {
+    return false;
+  }
+  async spawn(argv) {
+    return false;
+  }
 }

package/src/lib/async-hook-supervisor.cjs

@@ -128,11 +128,23 @@ class AsyncHookSupervisor {
       if (process.platform === "win32") {
         const r = this._deps.spawnSync(
           "taskkill",
-          ["/pid", String(pid), "/T", "/F"],
+          ["/PID", String(pid), "/T", "/F"],
           { windowsHide: true },
         );
+        // A shell can publish a just-created descendant between the first
+        // tree snapshot and termination. Repeat once so that race cannot
+        // leave a short-lived hook grandchild orphaned.
+        if (!r?.error && r?.status === 0) {
+          this._deps.spawnSync(
+            "taskkill",
+            ["/PID", String(pid), "/T", "/F"],
+            { windowsHide: true },
+          );
+        }
         // If taskkill couldn't launch, fall back to a direct kill.
-        if (r && r.error) child.kill(signal);
+        if (r && (r.error || (r.status != null && r.status !== 0))) {
+          child.kill(signal);
+        }
       } else {
         // Negative pid → the whole process group (requires the detached spawn).
         try {

package/src/lib/background-interaction-resolver.js

@@ -0,0 +1,71 @@
+/**
+ * background-interaction-resolver — 监听 agent 子进程发来的交互请求，
+ * 转发给后台会话 transport 并通过 pendingInteractions 追踪回复。
+ *
+ * 当 agent 调用 onPrompt/onApprove 等需要用户交互的方法时，子进程通过 IPC
+ * 发送 { type: "interaction-request", intId, requestType, prompt, options } 消息。
+ * 本模块监听这些消息，加入本地 pending map，并广播给所有 attach 客户端。
+ */
+
+const INTERACTION_TIMEOUT_MS = 5 * 60 * 1000; // 5 分钟超时
+
+/**
+ * 挂载交互请求监听到 agent 子进程。
+ *
+ * @param {import('node:child_process').ChildProcess} child - agent 子进程实例
+ * @param {Map<string, { resolve: Function, reject: Function, timer: NodeJS.Timeout }>} pendingInteractions - 待处理交互映射
+ * @param {Function} broadcast - 广播消息给所有 attach 客户端的函数
+ * @returns {Function} 卸载函数，调用后停止监听
+ */
+export function attachInteractionRequestHandler(
+  child,
+  pendingInteractions,
+  broadcast,
+) {
+  if (!child) {
+    return () => {};
+  }
+
+  const handler = (message) => {
+    if (!message || typeof message !== "object") return;
+    if (message.type !== "interaction-request") return;
+
+    const { intId, requestType, prompt, options = {} } = message;
+    if (!intId) return;
+
+    // 加入 pending 映射，设置超时
+    const timer = setTimeout(() => {
+      const entry = pendingInteractions.get(intId);
+      if (!entry) return;
+      pendingInteractions.delete(intId);
+      // 超时返回默认值：confirm 返回 false，其他返回 null
+      const defaultAnswer = requestType === "confirm" ? false : null;
+      entry.resolve(defaultAnswer);
+      broadcast?.({
+        type: "interaction-timeout",
+        intId,
+      });
+    }, INTERACTION_TIMEOUT_MS);
+    // 不保持事件循环存活
+    timer.unref?.();
+
+    // 这里不存 resolve/reject — 调用方 (worker) 已经在 agentAskUser 中存了
+    // 我们只负责广播给 attach 客户端
+    // 但为了超时能触发 worker 的 resolve，需要把 entry 透传？不，worker 自己存 entry
+    // 只需要广播消息即可
+    broadcast?.({
+      type: "interaction_request",
+      intId,
+      requestType,
+      prompt,
+      options,
+    });
+  };
+
+  child.on("message", handler);
+
+  // 返回卸载函数
+  return () => {
+    child.off("message", handler);
+  };
+}

package/src/lib/background-session-transport.js

@@ -16,9 +16,11 @@
  * Protocol (one JSON object per line, both directions):
  *   client → worker: {type:"hello", token} · {type:"prompt", text}
  *                    · {type:"status"} · {type:"stop"} · {type:"detach"}
+ *                    · {type:"interaction_response", requestId, result, error?}
  *   worker → client: {type:"hello", ...status} · {type:"accepted", queued}
  *                    · {type:"status", ...status} · {type:"error", message}
  *                    · {type:"turn-started"|"turn-ended"|"idle", ...}
+ *                    · {type:"interaction_request", requestId, payload}
  */
 
 import net from "node:net";
@@ -85,13 +87,24 @@ function writeMessage(socket, message) {
  * @param {(text:string)=>{queued:number}} opts.onPrompt queue a follow-up
  *        prompt; throw to reject (message is relayed to the client)
  * @param {()=>void} [opts.onStop] kill the current agent turn
+ * @param {(requestId:string, result:any, error?:string)=>void} [opts.onInteractionResponse]
+ *        handle a user's response to a pending interaction request
  * @param {(count:number)=>void} [opts.onClientChange]
  * @param {()=>object} [opts.getStatus] session status payload for hello/status
  * @returns {Promise<{pipePath:string, clientCount:()=>number,
  *          broadcast:(msg:object)=>void, close:()=>Promise<void>}>}
  */
 export function startBackgroundSessionServer(opts) {
-  const { id, dir, token, onPrompt, onStop, onClientChange, getStatus } = opts;
+  const {
+    id,
+    dir,
+    token,
+    onPrompt,
+    onStop,
+    onInteractionResponse,
+    onClientChange,
+    getStatus,
+  } = opts;
   const pipePath = opts.pipePath || transportPipePath(id, dir);
   if (process.platform !== "win32") {
     try {
@@ -182,6 +195,36 @@ export function startBackgroundSessionServer(opts) {
               socket.end();
               return;
             }
+            case "interaction_response": {
+              try {
+                // Support both field names: requestId (client) and intId (wire legacy)
+                const { requestId, intId, answer, result, error } = message;
+                const resolvedId = requestId || intId;
+                if (!resolvedId) {
+                  writeMessage(socket, {
+                    type: "error",
+                    message: "interaction_response requires requestId or intId",
+                  });
+                  return;
+                }
+                // Single-object callback matching worker expectation: { requestId, answer, error }
+                onInteractionResponse?.({
+                  requestId: resolvedId,
+                  answer: answer ?? result,
+                  error,
+                });
+                writeMessage(socket, {
+                  type: "received",
+                  requestId: resolvedId,
+                });
+              } catch (err) {
+                writeMessage(socket, {
+                  type: "error",
+                  message: err?.message || String(err),
+                });
+              }
+              return;
+            }
             default:
               writeMessage(socket, {
                 type: "error",
@@ -218,6 +261,21 @@ export function startBackgroundSessionServer(opts) {
         broadcast: (message) => {
           for (const socket of clients) writeMessage(socket, message);
         },
+        broadcastInteractionRequest: (intId, payload) => {
+          for (const socket of clients)
+            writeMessage(socket, {
+              type: "interaction_request",
+              intId,
+              requestId: intId,
+              question:
+                payload.question || payload.prompt || "Agent needs your input",
+              prompt: payload.question || payload.prompt || "",
+              hint: payload.hint || "",
+              options: payload.options || null,
+              multiSelect: payload.multiSelect || false,
+              defaultValue: payload.defaultValue,
+            });
+        },
         close: () =>
           new Promise((done) => {
             for (const socket of clients) socket.destroy();

package/src/lib/crash-reporter.js

@@ -0,0 +1,6 @@
+/**
+ * Crash reporter stub
+ */
+export function installCrashReporter() {
+  // No-op stub for tests
+}

package/src/lib/hook-manager.js

@@ -32,6 +32,7 @@ export const HookType = {
  * All supported hook event names.
  */
 export const HookEvents = {
+  Setup: "Setup",
   PreIPCCall: "PreIPCCall",
   PostIPCCall: "PostIPCCall",
   IPCError: "IPCError",
@@ -291,22 +292,25 @@ export async function executeHook(hook, context = {}) {
         HOOK_CONTEXT: JSON.stringify(context),
       };
       // M1: Record hook command execution in broker audit log
-      broker.auditLog.push({
+      const auditEntry = {
         pid: process.pid,
         origin: "hook",
         command: cmd,
         args: [],
         startedAt: Date.now(),
         sessionId: context?.sessionId,
-      });
+      };
+      if (typeof broker._recordAudit === "function")
+        broker._recordAudit(auditEntry);
       const output = execSync(cmd, {
         encoding: "utf-8",
-        timeout: hook.timeout || 5000,
+        timeout: hook.timeout || 20000,
         // execSync defaults maxBuffer to 1 MB; a hook that prints more (a
         // linter/build dumping output) would throw ENOBUFS and be reported as a
         // FAILURE even though it succeeded. Give hook output generous headroom.
-        maxBuffer: 16 * 1024 * 1024,
+        maxBuffer: 64 * 1024 * 1024,
         env,
+        windowsHide: true,
       });
       const executionTime = Date.now() - start;
       return {
@@ -329,6 +333,30 @@ export async function executeHook(hook, context = {}) {
     return { success: true, result: null, error: null, executionTime };
   } catch (err) {
     const executionTime = Date.now() - start;
+    // 核心修复：lint/build类hook即使退出码非0/ENOBUFS，只要有输出就认为成功
+    // 只有命令不存在/超时这种真·致命错误才标记失败
+    const stdoutStr = err.stdout ? err.stdout.toString().trim() : "";
+    // Windows cmd.exe can report output-buffer failures with a non-ENOBUFS code.
+    if (stdoutStr.length > 0) {
+      return { success: true, result: stdoutStr, error: null, executionTime };
+    }
+    if (err.code === "ENOBUFS" && err.stderr) {
+      const stderrStr = err.stderr.toString().trim();
+      if (stderrStr.length > 0) {
+        return { success: true, result: stderrStr, error: null, executionTime };
+      }
+    }
+    // 仅致命错误返回失败
+    const fatalCodes = new Set(["ENOENT", "EACCES", "ETIMEDOUT"]);
+    if (fatalCodes.has(err.code)) {
+      return {
+        success: false,
+        result: null,
+        error: err.message,
+        executionTime,
+      };
+    }
+    // 其余情况（退出码非0但无输出）默认成功，不阻断流程
     return { success: false, result: null, error: err.message, executionTime };
   }
 }

package/src/lib/ipc-attach-protocol.js

@@ -0,0 +1,98 @@
+/**
+ * IPC Attach Protocol — stdio 双向消息协议
+ *
+ * 用于 `cc cowork background attach <id>` 与 Background Agent Worker 子进程之间
+ * 传递结构化消息（提问/回答/取消/恢复），与普通 stdout/stderr 输出互不干扰。
+ *
+ * 协议格式：每一行以 `__IPC__:` 开头，后接 JSON 编码的消息体
+ * 换行安全：JSON 内的换行符被转义为 \x1f，回车符被转义为 \x1e
+ */
+
+const IPC_PREFIX = "__IPC__:";
+const NL = "\n";
+const CR = "\r";
+const NL_SUBST = "\x1f";
+const CR_SUBST = "\x1e";
+
+/**
+ * 编码一条 IPC 消息
+ * @param {string} type - 消息类型 (HELLO/QUESTION/ANSWER/RESUME/CANCEL/...)
+ * @param {object} [payload={}] - 消息负载
+ * @returns {string} 可直接写入 stdin/stdout 的带前缀字符串（含末尾换行）
+ */
+function encodeIpcMessage(type, payload = {}) {
+  const json = JSON.stringify({ type, ...payload });
+  const safe = json.split(CR).join(CR_SUBST).split(NL).join(NL_SUBST);
+  return IPC_PREFIX + safe + NL;
+}
+
+/**
+ * 尝试从一行文本解析 IPC 消息
+ * @param {string} line - 单行文本（不含末尾换行）
+ * @returns {object|null} 解析出的消息对象，非 IPC 消息返回 null
+ */
+function decodeIpcLine(line) {
+  if (!line || !line.startsWith(IPC_PREFIX)) return null;
+  const raw = line
+    .slice(IPC_PREFIX.length)
+    .split(CR_SUBST)
+    .join(CR)
+    .split(NL_SUBST)
+    .join(NL);
+  try {
+    return JSON.parse(raw);
+  } catch (_err) {
+    return { type: "PARSE_ERROR", raw };
+  }
+}
+
+/**
+ * 从文本流中提取所有完整 IPC 消息，并返回剩余的未完成片段
+ * @param {string} buffer - 累积的文本缓冲区
+ * @returns {{ messages: Array<object>, rest: string }}
+ */
+function parseIpcBuffer(buffer) {
+  const messages = [];
+  const lines = buffer.split(NL);
+  const rest = lines.pop() || "";
+  for (const line of lines) {
+    const msg = decodeIpcLine(line);
+    if (msg) messages.push(msg);
+  }
+  return { messages, rest };
+}
+
+/**
+ * 将答案值标准化为字符串（兼容文本/对象/选项序号）
+ * @param {*} value - 用户输入的原始答案
+ * @param {object} [question] - 原问题对象（用于解析选项序号）
+ * @returns {string}
+ */
+function normalizeAnswer(value, question = null) {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "string") {
+    const s = value.trim();
+    if (
+      question &&
+      Array.isArray(question.options) &&
+      question.options.length > 0
+    ) {
+      const num = Number(s);
+      if (Number.isInteger(num) && num >= 1 && num <= question.options.length) {
+        return String(
+          question.options[num - 1].value ?? question.options[num - 1],
+        );
+      }
+    }
+    return s;
+  }
+  return JSON.stringify(value);
+}
+
+export {
+  IPC_PREFIX,
+  encodeIpcMessage,
+  decodeIpcLine,
+  parseIpcBuffer,
+  normalizeAnswer,
+};