chainlesschain 0.162.170 → 0.162.172

package/src/lib/agent-ipc-bus.js

@@ -0,0 +1,331 @@
+/**
+ * Agent IPC Bus — M2: 后台Agent实时交互总线
+ * 对应文档 §2.2
+ *
+ * 解决后台agent运行期间不能提问/confirm/elicit的问题:
+ * - child agent 通过 IPC 发送 interaction_request
+ * - parent 路由给 UI/REPL/headless resolver
+ * - 结果通过 interaction_response 返回child
+ * - 支持超时、取消、默认值
+ */
+
+import { EventEmitter } from "node:events";
+import crypto from "node:crypto";
+
+/**
+ * @typedef {Object} InteractionRequest
+ * @property {string} requestId
+ * @property {string} agentId - child agent id
+ * @property {string} sessionId
+ * @property {string} turnId
+ * @property {'permission_prompt'|'human_input'|'question'|'confirm'|'elicit'|'mcp_elicit'} type
+ * @property {string} prompt
+ * @property {string[]} [choices]
+ * @property {any} [defaultValue]
+ * @property {number} [timeoutMs]
+ * @property {Object} [metadata]
+ */
+
+class AgentIPCBus extends EventEmitter {
+  constructor() {
+    super();
+    /** @type {Map<string, {req: InteractionRequest, resolve: Function, reject: Function, timer?: NodeJS.Timeout}>} */
+    this._pendingRequests = new Map();
+    /** @type {Map<string, Function>} resolvers by agentId */
+    this._agentResolvers = new Map();
+  }
+
+  /**
+   * Register an agent worker's send function so bus can route responses back
+   * @param {string} agentId
+   * @param {(msg: any) => void} sendToWorker
+   */
+  registerAgent(agentId, sendToWorker) {
+    this._agentResolvers.set(agentId, sendToWorker);
+    this.emit("agent:registered", { agentId });
+  }
+
+  unregisterAgent(agentId) {
+    this._agentResolvers.delete(agentId);
+    // Reject all pending for this agent
+    for (const [reqId, entry] of this._pendingRequests.entries()) {
+      if (entry.req.agentId === agentId) {
+        if (entry.timer) clearTimeout(entry.timer);
+        entry.reject(new Error(`Agent ${agentId} disconnected while waiting for response`));
+        this._pendingRequests.delete(reqId);
+      }
+    }
+    this.emit("agent:unregistered", { agentId });
+  }
+
+  /**
+   * Child agent calls this to request human interaction
+   * @param {string} agentId
+   * @param {Partial<InteractionRequest>} req
+   * @returns {Promise<any>}
+   */
+  requestInteraction(agentId, req) {
+    const requestId = crypto.randomUUID();
+    const fullReq = {
+      requestId,
+      agentId,
+      sessionId: req.sessionId,
+      turnId: req.turnId,
+      type: req.type || "question",
+      prompt: req.prompt,
+      choices: req.choices,
+      defaultValue: req.defaultValue,
+      timeoutMs: req.timeoutMs || 300000, // 5min default
+      metadata: req.metadata || {},
+    };
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingRequests.delete(requestId);
+        if (fullReq.defaultValue !== undefined) {
+          resolve(fullReq.defaultValue);
+        } else {
+          reject(new Error(`Interaction request ${requestId} timed out after ${fullReq.timeoutMs}ms`));
+        }
+        this.emit("request:timeout", fullReq);
+      }, fullReq.timeoutMs);
+
+      this._pendingRequests.set(requestId, { req: fullReq, resolve, reject, timer });
+      this.emit("request", fullReq);
+    });
+  }
+
+  /**
+   * Parent/UI calls this to respond to a pending request
+   * @param {string} requestId
+   * @param {any} response
+   */
+  respond(requestId, response) {
+    const entry = this._pendingRequests.get(requestId);
+    if (!entry) return false;
+    if (entry.timer) clearTimeout(entry.timer);
+    this._pendingRequests.delete(requestId);
+    entry.resolve(response);
+    this.emit("request:resolved", { requestId, response });
+    return true;
+  }
+
+  /**
+   * Reject/cancel a pending request
+   * @param {string} requestId
+   * @param {Error} [err]
+   */
+  cancel(requestId, err) {
+    const entry = this._pendingRequests.get(requestId);
+    if (!entry) return false;
+    if (entry.timer) clearTimeout(entry.timer);
+    this._pendingRequests.delete(requestId);
+    entry.reject(err || new Error("Interaction cancelled by user"));
+    this.emit("request:cancelled", { requestId });
+    return true;
+  }
+
+  /** Get pending interaction requests for UI */
+  getPendingRequests() {
+    return Array.from(this._pendingRequests.values()).map(e => e.req);
+  }
+
+  /** Number of pending requests */
+  get pendingCount() {
+    return this._pendingRequests.size;
+  }
+
+  /**
+   * Spawn a child agent process with standardized JSON-RPC over stdio protocol
+   * Aligned with Claude Code sub-agent spawn specification
+   * @param {string} command - Agent executable/script path
+   * @param {string[]} args - Command arguments
+   * @param {object} options - Spawn options
+   * @returns {Promise<{process: ChildProcess, agentId: string}>}
+   */
+  async spawnAgentProcess(command, args = [], options = {}) {
+    const { spawn } = await import("node:child_process");
+    const agentId = options.agentId || crypto.randomUUID();
+    const heartbeatMs = options.heartbeatMs || 30000;
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        env: {
+          ...process.env,
+          CHAINLESSCHAIN_AGENT_ID: agentId,
+          CHAINLESSCHAIN_AGENT_MODE: "subagent",
+          CHAINLESSCHAIN_IPC_PROTOCOL: "jsonrpc-stdio-v1",
+          ...options.env,
+        },
+        ...options.spawnOptions,
+      });
+
+      let buffer = "";
+      let initialized = false;
+      let heartbeatTimer = null;
+
+      // Handle stdout: line-delimited JSON-RPC
+      child.stdout.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || ""; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const msg = JSON.parse(line);
+            this._handleIncomingMessage(agentId, msg, child);
+            if (msg.method === "initialize" && !initialized) {
+              initialized = true;
+              this.registerAgent(agentId, (outMsg) => {
+                child.stdin.write(JSON.stringify(outMsg) + "\n");
+              });
+              // Send initialize response
+              child.stdin.write(JSON.stringify({
+                jsonrpc: "2.0",
+                id: msg.id,
+                result: {
+                  protocolVersion: "1.0",
+                  agentId,
+                  capabilities: { interaction: true, tools: true },
+                },
+              }) + "\n");
+              // Setup heartbeat
+              heartbeatTimer = setInterval(() => {
+                if (child.exitCode !== null) {
+                  clearInterval(heartbeatTimer);
+                  return;
+                }
+                child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "heartbeat" }) + "\n");
+              }, heartbeatMs);
+              resolve({ process: child, agentId });
+            }
+          } catch (e) {
+            this.emit("protocol:error", { agentId, error: e, raw: line });
+          }
+        }
+      });
+
+      // Handle stderr: pass through to logger
+      child.stderr.on("data", (chunk) => {
+        this.emit("agent:stderr", { agentId, data: chunk.toString("utf8") });
+        if (options.captureStderr !== false) {
+          process.stderr.write(`[agent:${agentId}] ${chunk}`);
+        }
+      });
+
+      child.on("error", (err) => {
+        if (heartbeatTimer) clearInterval(heartbeatTimer);
+        if (!initialized) reject(err);
+        this.emit("agent:error", { agentId, error: err });
+      });
+
+      child.on("exit", (code, signal) => {
+        if (heartbeatTimer) clearInterval(heartbeatTimer);
+        this.unregisterAgent(agentId);
+        this.emit("agent:exit", { agentId, code, signal });
+      });
+
+      // Timeout for initialization
+      setTimeout(() => {
+        if (!initialized) {
+          child.kill();
+          reject(new Error(`Agent ${agentId} initialization timed out`));
+        }
+      }, options.initTimeoutMs || 10000);
+    });
+  }
+
+  /**
+   * Handle incoming JSON-RPC message from child agent
+   * @private
+   */
+  _handleIncomingMessage(agentId, msg, child) {
+    if (!msg.jsonrpc || msg.jsonrpc !== "2.0") {
+      this.emit("protocol:warning", { agentId, msg, reason: "missing jsonrpc version" });
+      return;
+    }
+
+    // Handle requests (method + id)
+    if (msg.method && msg.id) {
+      if (msg.method === "interaction_request") {
+        this.requestInteraction(agentId, msg.params).then((result) => {
+          child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0",
+            id: msg.id,
+            result,
+          }) + "\n");
+        }).catch((err) => {
+          child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0",
+            id: msg.id,
+            error: { code: -32000, message: err.message },
+          }) + "\n");
+        });
+      } else if (msg.method === "log") {
+        this.emit("agent:log", { agentId, params: msg.params });
+        // Acknowledge log
+        child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: msg.id, result: true }) + "\n");
+      } else {
+        this.emit("agent:request", { agentId, msg });
+      }
+    }
+    // Handle notifications (method, no id)
+    else if (msg.method && !msg.id) {
+      if (msg.method === "heartbeat") {
+        this.emit("agent:heartbeat", { agentId });
+      } else if (msg.method === "progress") {
+        this.emit("agent:progress", { agentId, params: msg.params });
+      } else {
+        this.emit("agent:notification", { agentId, method: msg.method, params: msg.params });
+      }
+    }
+    // Handle responses (id + result/error)
+    else if (msg.id) {
+      this.emit("agent:response", { agentId, msg });
+    }
+  }
+
+  /**
+   * Send a JSON-RPC request to a spawned agent via stdio
+   * @param {string} agentId
+   * @param {string} method
+   * @param {any} params
+   * @param {number} [timeoutMs=30000]
+   * @returns {Promise<any>}
+   */
+  sendRequest(agentId, method, params = {}, timeoutMs = 30000) {
+    const sendToWorker = this._agentResolvers.get(agentId);
+    if (!sendToWorker) {
+      return Promise.reject(new Error(`Agent ${agentId} not registered`));
+    }
+    const id = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.removeAllListeners(`response:${id}`);
+        reject(new Error(`Request ${method} to agent ${agentId} timed out`));
+      }, timeoutMs);
+
+      const onResponse = (respMsg) => {
+        if (respMsg.msg.id === id) {
+          clearTimeout(timer);
+          this.off("agent:response", onResponse);
+          if (respMsg.msg.error) {
+            reject(new Error(respMsg.msg.error.message));
+          } else {
+            resolve(respMsg.msg.result);
+          }
+        }
+      };
+      this.on("agent:response", onResponse);
+
+      sendToWorker({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+}
+
+// Singleton
+const ipcBus = new AgentIPCBus();
+export default ipcBus;
+export { AgentIPCBus };

package/src/lib/agent-worktree.js

@@ -11,11 +11,18 @@
  *    a merge hint. Removal failures fail-open to "kept".
  */
 
-import { execSync } from "child_process";
+import { execFileSync, execSync } from "child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { resolve } from "node:path";
 import { createWorktree, removeWorktree } from "./worktree-isolator.js";
 import { findProjectRoot } from "./project-instructions.js";
 
-export const _deps = { execSync, createWorktree, removeWorktree };
+export const _deps = {
+  execFileSync,
+  execSync,
+  createWorktree,
+  removeWorktree,
+};
 
 function git(cmd, cwd, deps) {
   return (deps.execSync || execSync)(`git ${cmd}`, {
@@ -25,6 +32,132 @@ function git(cmd, cwd, deps) {
   });
 }
 
+function canonicalPath(value) {
+  const absolute = resolve(String(value || ""));
+  const real = realpathSync.native
+    ? realpathSync.native(absolute)
+    : realpathSync(absolute);
+  return process.platform === "win32" ? real.toLowerCase() : real;
+}
+
+function parseRegisteredWorktrees(text) {
+  const entries = [];
+  let current = null;
+  for (const line of String(text || "").split(/\r?\n/)) {
+    if (line.startsWith("worktree ")) {
+      if (current) entries.push(current);
+      current = { path: line.slice("worktree ".length) };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("HEAD ")) current.head = line.slice("HEAD ".length);
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length);
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}
+
+/**
+ * Verify that persisted worktree metadata still identifies the same linked
+ * worktree. Cleanup callers use this as a fail-closed identity check before
+ * invoking any removal primitive: a missing/corrupt path must never turn into
+ * a recursive delete of the repository checkout.
+ *
+ * @returns {{valid:boolean, reason:string}}
+ */
+export function validateAgentWorktree(info, { deps = _deps } = {}) {
+  const worktreePath = info?.path || info?.worktreePath;
+  if (!worktreePath || !info?.repoRoot || !info?.branch || !info?.baseSha) {
+    return { valid: false, reason: "incomplete worktree metadata" };
+  }
+  if (!/^[0-9a-f]{40,64}$/i.test(String(info.baseSha))) {
+    return { valid: false, reason: "invalid worktree base SHA" };
+  }
+  if (!existsSync(worktreePath) || !existsSync(info.repoRoot)) {
+    return { valid: false, reason: "worktree or repository path is missing" };
+  }
+
+  try {
+    const repo = canonicalPath(info.repoRoot);
+    const worktree = canonicalPath(worktreePath);
+    if (repo === worktree) {
+      return {
+        valid: false,
+        reason: "refusing to treat the main checkout as an agent worktree",
+      };
+    }
+
+    const repoTop = canonicalPath(
+      git("rev-parse --show-toplevel", info.repoRoot, deps).trim(),
+    );
+    const worktreeTop = canonicalPath(
+      git("rev-parse --show-toplevel", worktreePath, deps).trim(),
+    );
+    if (repoTop !== repo || worktreeTop !== worktree) {
+      return { valid: false, reason: "worktree path identity mismatch" };
+    }
+
+    const registered = parseRegisteredWorktrees(
+      git("worktree list --porcelain", info.repoRoot, deps),
+    ).find((entry) => {
+      try {
+        return canonicalPath(entry.path) === worktree;
+      } catch {
+        return false;
+      }
+    });
+    if (!registered) {
+      return {
+        valid: false,
+        reason: "path is not a registered worktree of the repository",
+      };
+    }
+    if (registered.branch !== `refs/heads/${info.branch}`) {
+      return {
+        valid: false,
+        reason: "registered worktree branch does not match persisted metadata",
+      };
+    }
+    return { valid: true, reason: "verified" };
+  } catch (error) {
+    return {
+      valid: false,
+      reason: `worktree identity could not be verified: ${error.message}`,
+    };
+  }
+}
+
+function removeVerifiedAgentWorktree(info, deps) {
+  // Unit seams historically inject removeWorktree directly. Keep that seam,
+  // while production uses a non-forced git removal: if the tree changed
+  // between inspection and deletion, git refuses instead of discarding it.
+  if (deps.removeWorktree && deps.removeWorktree !== removeWorktree) {
+    deps.removeWorktree(info.repoRoot, info.path);
+    return null;
+  }
+
+  const run = deps.execFileSync || execFileSync;
+  run("git", ["worktree", "remove", info.path], {
+    cwd: info.repoRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  try {
+    run("git", ["branch", "-D", "--", info.branch], {
+      cwd: info.repoRoot,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    return null;
+  } catch (error) {
+    // The worktree itself is already gone. Preserve an honest warning rather
+    // than claiming the whole cleanup failed and that the path was kept.
+    return `branch cleanup failed: ${error.message}`;
+  }
+}
+
 /**
  * @returns {{ path, branch, repoRoot, baseSha }}
  */
@@ -51,22 +184,57 @@ export function setupAgentWorktree({
 export function finishAgentWorktree(info, { deps = _deps } = {}) {
   if (!info) return { removed: false, kept: false, reason: "no worktree" };
 
+  // Production cleanup validates the persisted path against git's own
+  // worktree registry. Custom dependency bundles are test seams and retain the
+  // historical pure mocked behavior unless they provide validateWorktree.
+  const validation =
+    typeof deps.validateWorktree === "function"
+      ? deps.validateWorktree(info)
+      : deps === _deps
+        ? validateAgentWorktree(info, { deps })
+        : { valid: true, reason: "injected validation seam" };
+  if (!validation?.valid) {
+    return {
+      removed: false,
+      kept: true,
+      reason: `unverifiable worktree: ${validation?.reason || "unknown reason"}`,
+    };
+  }
+
   let dirty = true;
   let headSha = null;
+  let readable = false;
   try {
     dirty = git("status --porcelain", info.path, deps).trim().length > 0;
     headSha = git("rev-parse HEAD", info.path, deps).trim();
+    readable = true;
   } catch {
     /* unreadable → keep, never destroy work we cannot verify */
   }
 
+  if (!readable) {
+    return {
+      removed: false,
+      kept: true,
+      reason: "unverifiable worktree: git state could not be read",
+    };
+  }
+
   const hasCommits = headSha !== null && headSha !== info.baseSha;
   if (!dirty && !hasCommits) {
     try {
-      (deps.removeWorktree || removeWorktree)(info.repoRoot, info.path);
-      return { removed: true, kept: false, reason: "no changes" };
+      const warning = removeVerifiedAgentWorktree(info, deps);
+      return {
+        removed: true,
+        kept: false,
+        reason: warning ? `no changes; ${warning}` : "no changes",
+      };
     } catch (err) {
-      return { removed: false, kept: true, reason: `cleanup failed: ${err.message}` };
+      return {
+        removed: false,
+        kept: true,
+        reason: `cleanup failed: ${err.message}`,
+      };
     }
   }
   return {