@xyagent/cli 0.0.1

package/src-ext/runtime/claude/permissionPromptServer.mjs

@@ -0,0 +1,170 @@
+/**
+ * permissionPromptServer.mjs — 任务 1.1
+ *
+ * MCP stdio server 管理器。
+ * fork permissionPromptServerWorker.mjs 并桥接 approvalGateway。
+ *
+ * 工作流：
+ *   1. start() → fork worker，监听 IPC message
+ *   2. worker 收到 claude tools/call → IPC 发 { type: "openRequest", requestId, meta }
+ *   3. permissionPromptServer 收到 → 调 approvalGateway.openRequest(meta) 拿 { requestId: gwReqId, promise }
+ *      同时记录 workerRequestId → gwReqId 映射
+ *   4. caller（handleRequest.mjs）poll lastOpenedRequestId → 拿到 gwReqId，
+ *      发 interrupt block + waitForRunResumed + approvalGateway.settle
+ *   5. approvalGateway settle → promise resolve { decision, ... }
+ *   6. permissionPromptServer 监听 openRequest 的 promise，resolve 后 IPC 发 settle 给 worker
+ *   7. worker 返回 MCP tools/call 结果给 claude CLI
+ *
+ * 注意：生命周期随 claude 子进程共生（spawnClaude 前 start，finally stop）。
+ */
+
+import { fork } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKER_SCRIPT = path.join(__dirname, "permissionPromptServerWorker.mjs");
+
+/**
+ * @param {{
+ *   approvalGateway: ReturnType<import('../../core/approvalGateway.mjs').createApprovalGateway>,
+ *   log: any,
+ * }} opts
+ * @returns {{ start(): Promise<void>, stop(): Promise<void>, child: ChildProcess|null, getLastRequestId(): string|null }}
+ */
+export function createPermissionPromptServer({ approvalGateway, log }) {
+  if (!approvalGateway) throw new Error("createPermissionPromptServer: approvalGateway required");
+  if (!log) throw new Error("createPermissionPromptServer: log required");
+
+  const sLog = log.child ? log.child({ comp: "perm-prompt-server" }) : log;
+
+  let child = null;
+  let lastGwRequestId = null; // 最近一次 openRequest 返回的 gwRequestId（供 handleRequest pull）
+  let lastMeta = null; // 最近一次 openRequest 的 meta（tool_name, tool_input, tool_use_id）
+
+  async function start() {
+    if (child) {
+      sLog.warn?.("perm_server.already_started", "server already started");
+      return;
+    }
+
+    child = fork(WORKER_SCRIPT, [], {
+      stdio: ["pipe", "pipe", "pipe", "ipc"],
+      execArgv: [],
+    });
+
+    child.on("message", async (msg) => {
+      if (!msg || typeof msg !== "object") return;
+
+      if (msg.type === "openRequest") {
+        const { requestId: workerReqId, meta } = msg;
+        sLog.info?.("perm_server.open_request", "received openRequest from worker", {
+          workerReqId, tool: meta?.tool_name || "",
+        });
+
+        // 调用 approvalGateway
+        let gwResult;
+        try {
+          lastMeta = meta; // 记录 meta 供 handleRequest pull
+          const { requestId: gwReqId, promise } = approvalGateway.openRequest(meta);
+          lastGwRequestId = gwReqId;
+
+          // 异步等待 approve/reject（approvalGateway promise resolve → 发 settle 给 worker）
+          promise.then(({ decision }) => {
+            if (!child) return;
+            child.send({ type: "settle", requestId: workerReqId, decision });
+          }).catch((err) => {
+            // dispose() 触发 reject → deny
+            sLog.warn?.("perm_server.promise_rejected", "approval promise rejected, sending deny", {
+              err: err?.message || String(err),
+            });
+            if (!child) return;
+            child.send({
+              type: "settle",
+              requestId: workerReqId,
+              decision: "reject",
+              message: err?.message || "approval cancelled",
+            });
+          });
+        } catch (err) {
+          sLog.error?.("perm_server.open_request_failed", "approvalGateway.openRequest failed", {
+            err: err?.message || String(err),
+          });
+          // 发 deny 给 worker
+          if (child) {
+            child.send({
+              type: "settle",
+              requestId: workerReqId,
+              decision: "reject",
+              message: `gateway error: ${err?.message || String(err)}`,
+            });
+          }
+        }
+      }
+    });
+
+    child.on("error", (err) => {
+      sLog.error?.("perm_server.child_error", "worker process error", {
+        err: err?.message || String(err),
+      });
+    });
+
+    child.on("exit", (code, signal) => {
+      sLog.info?.("perm_server.child_exit", "worker process exited", { code, signal });
+    });
+
+    // 等待子进程初始化（给一点时间让 worker 开始监听 stdin）
+    await new Promise((r) => setTimeout(r, 50));
+
+    sLog.info?.("perm_server.started", "permission prompt server started", { pid: child.pid });
+  }
+
+  async function stop() {
+    if (!child) return;
+    const c = child;
+    child = null;
+    // 通知 worker 清理 pending（避免永久挂起）
+    try {
+      c.send({ type: "dispose" });
+    } catch { /* ignore */ }
+    // 等 worker 自然退出（stdin close 会让 worker exit）
+    try { c.stdin?.end(); } catch { /* ignore */ }
+    // 若 500ms 内未退出，SIGTERM
+    await new Promise((resolve) => {
+      const deadline = setTimeout(() => {
+        try { c.kill("SIGTERM"); } catch { /* ignore */ }
+        resolve();
+      }, 500);
+      c.once("exit", () => {
+        clearTimeout(deadline);
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * 返回最近一次 approvalGateway.openRequest 产生的 requestId。
+   * handleRequest.mjs 在 openRequest 后通过此方法获得 id，用于 pull 模式。
+   */
+  function getLastRequestId() {
+    return lastGwRequestId;
+  }
+
+  /**
+   * 返回最近一次 openRequest 的 meta（含 tool_name, tool_input, tool_use_id）。
+   * handleRequest.mjs 用于构造 interrupt block。
+   */
+  function getLastMeta() {
+    return lastMeta;
+  }
+
+  // 暴露 child（测试用）
+  return {
+    start,
+    stop,
+    get child() { return child; },
+    getLastRequestId,
+    getLastMeta,
+  };
+}

package/src-ext/runtime/claude/permissionPromptServerWorker.mjs

@@ -0,0 +1,214 @@
+/**
+ * permissionPromptServerWorker.mjs — MCP stdio server worker 进程
+ *
+ * 由 permissionPromptServer.mjs 通过 fork 启动（带 IPC channel）。
+ *
+ * 生命周期：
+ *   - 父进程通过 IPC message { type: "settle", requestId, decision, message } 回传结果
+ *   - 子进程通过 IPC message { type: "openRequest", requestId, meta } 请求审批
+ *   - MCP stdio（stdin/stdout）接 claude CLI 的 --permission-prompt-tool
+ *
+ * MCP 协议：JSON-RPC 2.0 over stdio（Content-Length framing）。
+ * 实现最小子集：initialize + tools/list + tools/call。
+ */
+
+import readline from "node:readline";
+import process from "node:process";
+
+// pending map: requestId → { resolve, reject }
+const pendingRequests = new Map();
+
+// ── IPC：父进程发来 settle 消息 ──────────────────────────────────────────────
+process.on("message", (msg) => {
+  if (!msg || typeof msg !== "object") return;
+  if (msg.type === "settle") {
+    const { requestId, decision, message: denyMsg } = msg;
+    const entry = pendingRequests.get(requestId);
+    if (!entry) return;
+    pendingRequests.delete(requestId);
+    entry.resolve({ decision, message: denyMsg || "" });
+  }
+  if (msg.type === "dispose") {
+    // 父进程关闭时，拒绝所有 pending
+    for (const [id, entry] of pendingRequests) {
+      pendingRequests.delete(id);
+      entry.resolve({ decision: "reject", message: "bridge disposed" });
+    }
+  }
+});
+
+// ── MCP stdio framing ─────────────────────────────────────────────────────────
+
+let outputBuf = "";
+
+function sendMessage(msg) {
+  const body = JSON.stringify(msg);
+  process.stdout.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+}
+
+function sendResponse(id, result) {
+  sendMessage({ jsonrpc: "2.0", id, result });
+}
+
+function sendError(id, code, message) {
+  sendMessage({ jsonrpc: "2.0", id, error: { code, message } });
+}
+
+// 读 stdin，按 Content-Length 帧解析
+async function readFrames() {
+  let buf = Buffer.alloc(0);
+
+  process.stdin.on("data", async (chunk) => {
+    buf = Buffer.concat([buf, chunk]);
+
+    while (true) {
+      // 找 \r\n\r\n 分隔符
+      const sepStr = "\r\n\r\n";
+      const sepBuf = Buffer.from(sepStr, "utf8");
+      let sepIdx = -1;
+      for (let i = 0; i <= buf.length - sepBuf.length; i++) {
+        if (buf.subarray(i, i + sepBuf.length).equals(sepBuf)) {
+          sepIdx = i;
+          break;
+        }
+      }
+      if (sepIdx === -1) break;
+
+      const header = buf.subarray(0, sepIdx).toString("utf8");
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        // 无法解析 header，跳过至下一帧
+        buf = buf.subarray(sepIdx + sepBuf.length);
+        continue;
+      }
+      const bodyLen = parseInt(match[1], 10);
+      const bodyStart = sepIdx + sepBuf.length;
+      if (buf.length < bodyStart + bodyLen) break; // 数据不够，等下一次
+
+      const bodyStr = buf.subarray(bodyStart, bodyStart + bodyLen).toString("utf8");
+      buf = buf.subarray(bodyStart + bodyLen);
+
+      let msg;
+      try {
+        msg = JSON.parse(bodyStr);
+      } catch {
+        continue;
+      }
+      // 异步处理（不阻塞 data 事件）
+      handleMessage(msg).catch(() => {});
+    }
+  });
+
+  process.stdin.on("end", () => {
+    // stdin 关闭（claude 子进程退出），worker 自动退出
+    process.exit(0);
+  });
+  process.stdin.on("error", () => {
+    process.exit(0);
+  });
+}
+
+// ── MCP 消息处理 ──────────────────────────────────────────────────────────────
+
+async function handleMessage(msg) {
+  if (!msg || typeof msg !== "object") return;
+  const { jsonrpc, id, method, params } = msg;
+
+  // Notification（无 id），直接返回
+  if (id === undefined || id === null) {
+    return;
+  }
+
+  if (method === "initialize") {
+    sendResponse(id, {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "agentlink-permission", version: "1.0.0" },
+    });
+    return;
+  }
+
+  if (method === "tools/list") {
+    sendResponse(id, {
+      tools: [
+        {
+          name: "agentlink_permission_prompt",
+          description: "AgentLink permission approval tool. Called by Claude CLI when a tool requires user authorization.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              tool_name: { type: "string", description: "Name of the tool requesting permission" },
+              input: { type: "object", description: "Tool input arguments" },
+              tool_use_id: { type: "string", description: "Tool use ID from Claude" },
+            },
+            required: ["tool_name", "input", "tool_use_id"],
+          },
+        },
+      ],
+    });
+    return;
+  }
+
+  if (method === "tools/call") {
+    const toolName = params?.name;
+    if (toolName !== "agentlink_permission_prompt") {
+      sendError(id, -32601, `Unknown tool: ${toolName}`);
+      return;
+    }
+    const args = params?.arguments ?? {};
+    await handlePermissionPrompt(id, args);
+    return;
+  }
+
+  // 未知方法
+  sendError(id, -32601, `Method not found: ${method}`);
+}
+
+async function handlePermissionPrompt(mcpCallId, args) {
+  const { tool_name, input, tool_use_id } = args;
+
+  // 生成 requestId 并通知父进程（openRequest）
+  const requestId = `perm_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+
+  // 注册 pending promise（等待父进程 settle）
+  let resolveFn;
+  const waitPromise = new Promise((resolve) => {
+    resolveFn = resolve;
+  });
+  pendingRequests.set(requestId, { resolve: resolveFn });
+
+  // 通知父进程：需要一个审批 request
+  if (process.send) {
+    process.send({
+      type: "openRequest",
+      requestId,
+      meta: { tool_name, tool_input: input, tool_use_id },
+    });
+  } else {
+    // 没有 IPC channel（测试环境非 fork 模式），自动 deny
+    resolveFn({ decision: "reject", message: "no IPC channel" });
+  }
+
+  let result;
+  try {
+    result = await waitPromise;
+  } catch {
+    result = { decision: "reject", message: "worker error" };
+  }
+
+  const { decision, message: denyMsg } = result;
+
+  let responseObj;
+  if (decision === "approve") {
+    responseObj = { behavior: "allow", updatedInput: input };
+  } else {
+    responseObj = { behavior: "deny", message: denyMsg || "User denied in AgentLink App." };
+  }
+
+  sendResponse(mcpCallId, {
+    content: [{ type: "text", text: JSON.stringify(responseObj) }],
+  });
+}
+
+// 启动
+readFrames();

package/src-ext/runtime/claude/preflight.mjs

@@ -0,0 +1,62 @@
+// Claude 预检：只确认二进制存在 + 拿到版本号。
+// 登录 / apikey 由用户自理 —— 首次 spawn 失败时再把原始 stderr 透传给 App。
+//
+// 跨平台：Windows 上 `claude` 可能是 `.cmd` 包装。用 `shell: true` 的 `execFile`
+// 同步版本（`spawnSync`）让 shell 解释。
+
+import { spawnSync } from "node:child_process";
+import process from "node:process";
+
+const PREFLIGHT_TIMEOUT_MS = 5000;
+
+/**
+ * @returns {{ ok: boolean, version?: string, error?: string, hint?: string }}
+ */
+export function claudePreflight({ log } = {}) {
+  const isWin = process.platform === "win32";
+  const pfLog = log ? log.child({ comp: "child", stage: "preflight" }) : null;
+
+  // 用 shell 以便 Windows 找到 .cmd shim；代价是参数无法含 shell 特殊字符 ——
+  // 我们只传 `--version` 无副作用。
+  let res;
+  try {
+    res = spawnSync("claude", ["--version"], {
+      encoding: "utf8",
+      timeout: PREFLIGHT_TIMEOUT_MS,
+      shell: isWin ? true : false,
+    });
+  } catch (err) {
+    pfLog?.error("bridge.preflight.fail", "spawn threw", { err: err?.message || String(err) });
+    return {
+      ok: false,
+      error: `spawn failed: ${err?.message || String(err)}`,
+      hint: "请确认 claude 已安装并在 PATH 中",
+    };
+  }
+
+  if (res.error) {
+    const isENOENT = res.error.code === "ENOENT";
+    pfLog?.error("bridge.preflight.fail", "spawn errored", {
+      code: res.error.code, err: res.error.message,
+    });
+    return {
+      ok: false,
+      error: res.error.message,
+      hint: isENOENT
+        ? "未找到 `claude` 命令。请先安装 @anthropic-ai/claude-code 并登录。"
+        : "spawn claude 失败",
+    };
+  }
+  if (res.status !== 0) {
+    const tail = (res.stderr || res.stdout || "").trim().slice(-400);
+    pfLog?.error("bridge.preflight.fail", "non-zero exit", { code: res.status, tail });
+    return {
+      ok: false,
+      error: `claude --version exit ${res.status}: ${tail}`,
+      hint: "claude 启动报错，可能未登录或配置缺失",
+    };
+  }
+  const version = (res.stdout || "").trim().split(/\r?\n/)[0] || "unknown";
+  pfLog?.info("bridge.preflight.pass", "claude binary ok", { version });
+  return { ok: true, version };
+}