team-anya 0.2.0

package/packages/cc-client/dist/claude-code-backend.js

@@ -0,0 +1,792 @@
+import { spawn, execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync, appendFileSync, unlinkSync, existsSync, mkdirSync, } from "node:fs";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { WebSocketServer, WebSocket } from "ws";
+import { ConnectionState } from "@team-anya/core";
+export class ClaudeCodeBackend {
+    proc = null;
+    ws = null;
+    wsServer = null;
+    httpServer = null;
+    cliSessionId = null;
+    config = null;
+    verbose;
+    // 事件回调
+    toolRequestHandler = null;
+    resultHandler = null;
+    progressHandler = null;
+    stateChangeHandler = null;
+    sessionIdHandler = null;
+    // system/init 信息（异步更新，供外部查询）
+    initMessage = null;
+    // 消息队列：CLI WS 未连接时暂存待发消息
+    pendingMessages = [];
+    // .mcp.json 管理：记录原始内容用于恢复
+    mcpJsonPath = null;
+    mcpJsonBackup = null; // null = 文件原本不存在
+    mcpJsonCreated = false;
+    // 原始对话日志：收集每次 prompt 执行期间的所有 NDJSON 消息
+    rawConversationLog = [];
+    // 日志文件路径
+    logFile = null;
+    logDirEnsured = false;
+    // 限流信息：rate_limit_event 到达时暂存，供后续 result 处理时使用
+    rateLimitInfo = null;
+    constructor(options) {
+        this.verbose = options?.verbose ?? false;
+        this.logFile = options?.logFile ?? null;
+    }
+    /** 确保日志文件的父目录存在（仅首次调用时创建） */
+    ensureLogDir() {
+        if (this.logDirEnsured || !this.logFile)
+            return;
+        try {
+            const dir = this.logFile.substring(0, this.logFile.lastIndexOf("/"));
+            if (dir)
+                mkdirSync(dir, { recursive: true });
+        }
+        catch {
+            // 创建失败不阻断
+        }
+        this.logDirEnsured = true;
+    }
+    /** 格式化可读时间：2026-03-02 15:30:45 */
+    static formatTime(date) {
+        const Y = date.getFullYear();
+        const M = String(date.getMonth() + 1).padStart(2, "0");
+        const D = String(date.getDate()).padStart(2, "0");
+        const h = String(date.getHours()).padStart(2, "0");
+        const m = String(date.getMinutes()).padStart(2, "0");
+        const s = String(date.getSeconds()).padStart(2, "0");
+        return `${Y}-${M}-${D} ${h}:${m}:${s}`;
+    }
+    /**
+     * 日志输出：
+     * - error: 始终输出到控制台 stderr + 写文件
+     * - warn/info: 如果配置了 logFile 则写文件，否则输出到控制台
+     */
+    log(level, ...args) {
+        if (level === "info" && !this.verbose)
+            return;
+        const ts = ClaudeCodeBackend.formatTime(new Date());
+        const prefix = `[cc-backend ${ts}]`;
+        if (level === "error") {
+            console.error(prefix, ...args);
+            this.appendToLogFile(prefix, ...args);
+        }
+        else if (this.logFile) {
+            // warn/info 日志写入文件，不输出到控制台
+            this.appendToLogFile(prefix, ...args);
+        }
+        else if (level === "warn") {
+            console.warn(prefix, ...args);
+        }
+        else {
+            console.log(prefix, ...args);
+        }
+    }
+    /**
+     * 记录原始 WS 消息到日志文件（JSON 格式，含可读时间）
+     */
+    logRawMessage(direction, msg) {
+        if (!this.logFile)
+            return;
+        this.ensureLogDir();
+        try {
+            const now = new Date();
+            const entry = JSON.stringify({
+                time: ClaudeCodeBackend.formatTime(now),
+                ts: now.getTime(),
+                dir: direction,
+                msg,
+            });
+            appendFileSync(this.logFile, entry + "\n");
+        }
+        catch {
+            // 日志写入失败不影响主流程
+        }
+    }
+    appendToLogFile(...parts) {
+        if (!this.logFile)
+            return;
+        this.ensureLogDir();
+        try {
+            const line = parts
+                .map((p) => (typeof p === "string" ? p : JSON.stringify(p)))
+                .join(" ");
+            appendFileSync(this.logFile, line + "\n");
+        }
+        catch {
+            // 日志写入失败不影响主流程
+        }
+    }
+    async connect(config) {
+        this.config = config;
+        this.initMessage = null;
+        this.cliSessionId = null;
+        this.pendingMessages = [];
+        this.stateChangeHandler?.(ConnectionState.CONNECTING);
+        this.log("info", "开始连接, binary:", config.binary ?? "claude", "workingDir:", config.workingDir);
+        const port = await this.findFreePort();
+        this.log("info", `WS 服务监听端口: ${port}`);
+        // 1. 启动 WebSocket Server，等待 CLI 反连
+        const wsReady = new Promise((resolve, reject) => {
+            this.httpServer = createServer();
+            this.wsServer = new WebSocketServer({ server: this.httpServer });
+            this.wsServer.on("connection", (ws, req) => {
+                this.log("warn", `CLI WebSocket 已连接, url=${req.url}, headers=${JSON.stringify(req.headers)}`);
+                this.ws = ws;
+                this.setupMessageHandler(ws);
+                resolve(ws);
+            });
+            this.httpServer.on("listening", () => {
+                this.log("warn", `HTTP server 已启动, 监听 127.0.0.1:${port}`);
+            });
+            this.httpServer.on("request", (req) => {
+                this.log("warn", `[HTTP] 收到请求: ${req.method} ${req.url}`);
+            });
+            this.httpServer.on("upgrade", (req) => {
+                this.log("warn", `[HTTP] 收到 upgrade 请求: ${req.url}, headers=${JSON.stringify(req.headers)}`);
+            });
+            this.httpServer.listen(port, "127.0.0.1");
+            this.httpServer.on("error", (err) => {
+                this.log("error", "HTTP server 错误:", err.message);
+                reject(err);
+            });
+        });
+        // 2. 启动 Claude Code CLI 子进程
+        const sessionId = randomUUID();
+        const sdkUrl = `ws://127.0.0.1:${port}/ws/cli/${sessionId}`;
+        const args = [
+            "--sdk-url",
+            sdkUrl,
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--input-format",
+            "stream-json",
+            "--verbose",
+        ];
+        if (config.model)
+            args.push("--model", config.model);
+        if (config.resumeSessionId)
+            args.push("--resume", config.resumeSessionId);
+        if (config.systemPrompt)
+            args.push("--system-prompt", config.systemPrompt);
+        if (config.maxTurns)
+            args.push("--max-turns", String(config.maxTurns));
+        if (config.dangerouslySkipPermissions) {
+            args.push("--dangerously-skip-permissions");
+        }
+        else if (config.permissionMode) {
+            args.push("--permission-mode", config.permissionMode);
+        }
+        args.push("-p", ""); // headless 模式占位（参照 companion）
+        // MCP servers：写入 .mcp.json 到 workingDir（CLI 从 cwd 读取项目级配置）
+        if (config.mcpServers && config.mcpServers.length > 0) {
+            this.writeMcpJson(config.workingDir, config.mcpServers);
+        }
+        // 参照 companion: 用 which 解析 CLI 绝对路径
+        let binary = config.binary ?? "claude";
+        if (!binary.startsWith("/")) {
+            try {
+                binary = execSync(`which ${binary}`, { encoding: "utf-8" }).trim();
+                this.log("info", `解析 CLI 路径: ${binary}`);
+            }
+            catch {
+                this.log("warn", `无法解析 ${binary} 绝对路径，使用原值`);
+            }
+        }
+        this.log("error", `启动 CLI: ${binary} ${args.join(" ")} | cwd=${config.workingDir}`);
+        // 参照 companion (cli-launcher.ts:285-289):
+        // companion 设置 CLAUDECODE=1 标识 SDK 模式，但它是独立进程。
+        // 当从 Claude Code 会话内启动时，需要清理所有 CLAUDECODE/CLAUDE_CODE_*
+        // 环境变量避免嵌套检测。--sdk-url 本身已足够标识 SDK 模式。
+        const cleanEnv = {};
+        for (const [key, val] of Object.entries(process.env)) {
+            if (key === "CLAUDECODE" || key.startsWith("CLAUDE_CODE_"))
+                continue;
+            cleanEnv[key] = val;
+        }
+        // 二次清洗：config.env 可能把 CLAUDECODE/CLAUDE_CODE_* 又注入回来
+        const mergedEnv = {
+            ...cleanEnv,
+            ...config.env,
+        };
+        for (const key of Object.keys(mergedEnv)) {
+            if (key === "CLAUDECODE" || key.startsWith("CLAUDE_CODE_")) {
+                delete mergedEnv[key];
+            }
+        }
+        this.proc = spawn(binary, args, {
+            cwd: config.workingDir,
+            env: mergedEnv,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        // 收集 stdout/stderr 用于超时诊断
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        this.proc.stdout?.on("data", (data) => {
+            const text = data.toString().trim();
+            if (text)
+                stdoutChunks.push(text);
+        });
+        this.proc.stderr?.on("data", (data) => {
+            const text = data.toString().trim();
+            if (text)
+                stderrChunks.push(text);
+            this.log("warn", "CLI stderr:", text);
+        });
+        this.proc.on("error", (err) => {
+            this.log("error", "CLI 进程错误:", err.message);
+            this.stateChangeHandler?.(ConnectionState.ERROR);
+        });
+        // 进程提前退出时，让 wsReady 立即 reject 而非等到超时
+        this.proc.on("exit", (code, signal) => {
+            this.log("info", `CLI 进程退出, code=${code}, signal=${signal}`);
+        });
+        const earlyExit = new Promise((_, reject) => {
+            this.proc.on("exit", (code, signal) => {
+                const stdout = stdoutChunks.join("\n");
+                const stderr = stderrChunks.join("\n");
+                reject(new Error(`CLI 进程在连接前退出 (code=${code}, signal=${signal})` +
+                    (stdout ? `\nstdout:\n${stdout}` : "") +
+                    (stderr ? `\nstderr:\n${stderr}` : "")));
+            });
+        });
+        // 3. 等待 CLI 反连（不等待 system/init，参照 companion 非阻塞模式）
+        const connectTimeout = config.timeout?.connect ?? 30_000;
+        this.log("warn", `等待 CLI 反连, 超时: ${connectTimeout}ms`);
+        // 超时时附带进程状态和 stdout/stderr 便于诊断
+        const timeoutWithDiag = new Promise((_, reject) => {
+            setTimeout(() => {
+                const alive = this.proc && this.proc.exitCode === null && !this.proc.killed;
+                const stdout = stdoutChunks.join("\n");
+                const stderr = stderrChunks.join("\n");
+                const processState = alive
+                    ? "运行中"
+                    : `已退出 (code=${this.proc?.exitCode}, signal=${this.proc?.signalCode})`;
+                const diag = [
+                    `CLI 连接超时 (${connectTimeout}ms)`,
+                    `进程状态: ${processState}`,
+                    stdout
+                        ? `stdout (最后 500 字符):\n${stdout.slice(-500)}`
+                        : "stdout: (空)",
+                    stderr ? `stderr:\n${stderr}` : "stderr: (空)",
+                ].join("\n");
+                // 先输出日志确保诊断信息可见（不依赖上层 Error 序列化）
+                this.log("error", `CLI 连接超时诊断: 进程=${processState}, stdout=${stdout.length}字符, stderr=${stderr.length}字符`);
+                if (stderr)
+                    this.log("error", `CLI stderr 内容: ${stderr}`);
+                if (stdout)
+                    this.log("error", `CLI stdout 尾部: ${stdout.slice(-500)}`);
+                reject(new Error(diag));
+            }, connectTimeout);
+        });
+        this.ws = await Promise.race([wsReady, earlyExit, timeoutWithDiag]);
+        // system/init 到达时会异步更新 cliSessionId（在 routeMessage 中处理）
+        this.log("warn", `连接就绪, sessionId=${sessionId} (system/init 将异步更新)`);
+        this.stateChangeHandler?.(ConnectionState.CONNECTED);
+        return {
+            sessionId,
+            backendType: "claude-code",
+            model: config.model ?? "unknown",
+            tools: [],
+            capabilities: {
+                supportsResume: true,
+                supportsStreaming: true,
+                supportsToolApproval: true,
+                supportsModelSwitch: true,
+            },
+        };
+    }
+    async sendPrompt(prompt, _options) {
+        this.stateChangeHandler?.(ConnectionState.EXECUTING);
+        // 重置原始对话日志（每次 sendPrompt 开始新的收集周期）
+        this.rawConversationLog = [];
+        // 参照 companion (ws-bridge.ts:848-854)
+        const msg = {
+            type: "user",
+            message: { role: "user", content: prompt },
+            parent_tool_use_id: null,
+            session_id: this.cliSessionId ?? "",
+        };
+        const ndjson = JSON.stringify(msg);
+        // 记录发出的消息
+        this.rawConversationLog.push({
+            direction: "sent",
+            timestamp: new Date().toISOString(),
+            message: msg,
+        });
+        this.logRawMessage("sent", msg);
+        // this.log(
+        //   "info",
+        //   `[WS 发] sendPrompt: ${ndjson.slice(0, 500)}${ndjson.length > 500 ? "...(截断)" : ""}`,
+        // );
+        this.sendToCLI(ndjson);
+    }
+    async interrupt() {
+        // 参照 companion (ws-bridge.ts:899-905)
+        const msg = {
+            type: "control_request",
+            request_id: randomUUID(),
+            request: { subtype: "interrupt" },
+        };
+        const ndjson = JSON.stringify(msg);
+        this.rawConversationLog.push({
+            direction: "sent",
+            timestamp: new Date().toISOString(),
+            message: msg,
+        });
+        this.logRawMessage("sent", msg);
+        // this.log("info", `[WS 发] interrupt: ${ndjson}`);
+        this.sendToCLI(ndjson);
+    }
+    async resume(sessionId) {
+        await this.dispose();
+        if (!this.config)
+            throw new Error("No config available for resume");
+        // 参照 companion (cli-launcher.ts:219-224): 用 cliSessionId 恢复会话
+        return this.connect({
+            ...this.config,
+            resumeSessionId: sessionId,
+        });
+    }
+    getCapabilities() {
+        return {
+            supportsResume: true,
+            supportsStreaming: true,
+            supportsToolApproval: true,
+            supportsModelSwitch: true,
+        };
+    }
+    async dispose() {
+        // 参照 companion (cli-launcher.ts:507-532): SIGTERM → 等待 → SIGKILL
+        if (this.proc) {
+            const proc = this.proc;
+            const alreadyExited = proc.exitCode !== null || proc.signalCode !== null;
+            if (!alreadyExited) {
+                proc.kill("SIGTERM");
+                await new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        proc.kill("SIGKILL");
+                        resolve();
+                    }, 5_000);
+                    proc.on("exit", () => {
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+            }
+            this.proc = null;
+        }
+        this.ws?.close();
+        this.ws = null;
+        this.wsServer?.close();
+        this.wsServer = null;
+        this.httpServer?.close();
+        this.httpServer = null;
+        this.restoreMcpJson();
+        this.stateChangeHandler?.(ConnectionState.DISCONNECTED);
+    }
+    onToolRequest(handler) {
+        this.toolRequestHandler = handler;
+    }
+    onResult(handler) {
+        this.resultHandler = handler;
+    }
+    onProgress(handler) {
+        this.progressHandler = handler;
+    }
+    onStateChange(handler) {
+        this.stateChangeHandler = handler;
+    }
+    onSessionId(handler) {
+        this.sessionIdHandler = handler;
+    }
+    getCliSessionId() {
+        return this.cliSessionId;
+    }
+    // ── 私有方法 ──
+    /**
+     * 统一发送入口：WS 未就绪时消息入队，就绪时直接发送。
+     * 参照 companion 非阻塞队列模式。
+     */
+    sendToCLI(ndjson) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            this.log("warn", `[WS] CLI 未就绪 (ws=${this.ws ? `readyState=${this.ws.readyState}` : "null"})，消息入队 (queue=${this.pendingMessages.length + 1})`);
+            this.pendingMessages.push(ndjson);
+            return;
+        }
+        // this.log(
+        //   "warn",
+        //   `[WS 发] ${ndjson.slice(0, 500)}${ndjson.length > 500 ? "...(截断)" : ""}`,
+        // );
+        this.ws.send(ndjson + "\n");
+    }
+    setupMessageHandler(ws) {
+        // WS 连接建立后立即刷新排队消息
+        if (this.pendingMessages.length > 0) {
+            this.log("info", `[WS] 刷新 ${this.pendingMessages.length} 条排队消息`);
+            const queued = this.pendingMessages.splice(0);
+            for (const ndjson of queued) {
+                this.sendToCLI(ndjson);
+            }
+        }
+        let buffer = "";
+        ws.on("message", (data) => {
+            const raw = data.toString();
+            this.log("info", `[WS 收] ${raw.slice(0, 5000)}${raw.length > 5000 ? "...(截断)" : ""}`);
+            buffer += raw;
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    this.routeMessage(msg);
+                }
+                catch (err) {
+                    this.log("warn", `[WS 收] JSON 解析失败: ${err.message}, raw=${line.slice(0, 200)}`);
+                }
+            }
+        });
+        ws.on("close", (code, reason) => {
+            this.log("warn", `[WS] 连接关闭, code=${code}, reason=${reason.toString()}`);
+        });
+        ws.on("error", (err) => {
+            this.log("error", `[WS] 连接错误:`, err.message);
+        });
+        ws.on("ping", () => {
+            // this.log("warn", "[WS] 收到 ping");
+        });
+        ws.on("pong", () => {
+            // this.log("warn", "[WS] 收到 pong");
+        });
+    }
+    /**
+     * 参照 companion (ws-bridge.ts:550-591): 按 type 路由 CLI 消息
+     */
+    routeMessage(msg) {
+        // 收到任何消息即证明连接存活，通知 BackendManager 重置心跳计数
+        this.progressHandler?.({ type: "heartbeat", timestamp: Date.now() });
+        // 记录收到的原始消息到对话日志 + 写入日志文件
+        this.rawConversationLog.push({
+            direction: "received",
+            timestamp: new Date().toISOString(),
+            message: msg,
+        });
+        this.logRawMessage("recv", msg);
+        const msgType = `${msg.type}${msg.subtype ? "/" + msg.subtype : ""}`;
+        this.log("info", `[路由] type=${msgType}${msg.session_id ? ` sid=${msg.session_id}` : ""}${msg.hook_name ? ` hook=${msg.hook_name}` : ""}`);
+        switch (msg.type) {
+            case "system":
+                // 参照 companion (ws-bridge.ts:594-641): 只有 subtype=init 才是初始化消息
+                // 异步更新 cliSessionId 和 initMessage，不阻塞连接流程
+                if (msg.subtype === "init") {
+                    this.log("info", `[路由] system/init 详情: model=${msg.model}, tools=${JSON.stringify(msg.tools ?? [])}`);
+                    this.initMessage = msg;
+                    this.cliSessionId = msg.session_id ?? this.cliSessionId;
+                    if (this.cliSessionId) {
+                        this.sessionIdHandler?.(this.cliSessionId);
+                    }
+                }
+                break;
+            case "assistant":
+                this.log("info", `[路由] assistant 内容块数: ${msg.message?.content?.length ?? 0}`);
+                this.handleAssistant(msg);
+                break;
+            case "stream_event":
+                this.handleStreamEvent(msg.event);
+                break;
+            case "result": {
+                const preview = typeof msg.result === "string"
+                    ? msg.result.slice(0, 200)
+                    : JSON.stringify(msg.result ?? null).slice(0, 200);
+                this.log("info", `[路由] result: is_error=${msg.is_error}, turns=${msg.num_turns}, preview=${preview}`);
+                this.handleResult(msg);
+                break;
+            }
+            case "control_request":
+                this.log("info", `[路由] control_request: subtype=${msg.request?.subtype}, tool=${msg.request?.tool_name ?? "N/A"}`);
+                if (msg.request?.subtype === "can_use_tool") {
+                    this.handleToolApproval(msg);
+                }
+                break;
+            case "tool_progress":
+                this.progressHandler?.({
+                    type: "tool_progress",
+                    toolName: msg.tool_name ?? "unknown",
+                    output: msg.output ?? "",
+                });
+                break;
+            case "rate_limit_event": {
+                const info = msg.rate_limit_info;
+                if (info?.status === "rejected") {
+                    this.log("warn", `[路由] 触发限流: status=${info.status}, type=${info?.rateLimitType}, resetsAt=${info?.resetsAt}`);
+                    this.rateLimitInfo = {
+                        resetsAt: info?.resetsAt ?? 0,
+                        rateLimitType: info?.rateLimitType ?? "unknown",
+                    };
+                }
+                else {
+                    this.log("info", `[路由] 限流状态正常: status=${info?.status}, type=${info?.rateLimitType}`);
+                }
+                break;
+            }
+            case "keep_alive":
+            case "user":
+                // 静默消费（user 是 CLI 回传的 tool_use_result）
+                break;
+            default:
+                this.log("warn", `[路由] 未知消息类型: ${msg.type}, keys=${Object.keys(msg).join(",")}`);
+                break;
+        }
+    }
+    handleAssistant(msg) {
+        if (msg.message?.content) {
+            for (const block of msg.message.content) {
+                if (block.type === "text") {
+                    this.progressHandler?.({ type: "text_chunk", text: block.text });
+                }
+                else if (block.type === "thinking") {
+                    this.progressHandler?.({ type: "thinking", text: block.thinking });
+                }
+            }
+        }
+    }
+    handleStreamEvent(event) {
+        if (!event)
+            return;
+        if (event.type === "content_block_delta") {
+            if (event.delta?.type === "text_delta") {
+                this.progressHandler?.({ type: "text_chunk", text: event.delta.text });
+            }
+        }
+    }
+    handleResult(msg) {
+        const result = {
+            status: msg.is_error ? "error" : "success",
+            resultText: msg.result,
+            errors: msg.errors,
+            metrics: {
+                durationMs: msg.duration_ms ?? 0,
+                numTurns: msg.num_turns ?? 0,
+                totalCostUsd: msg.total_cost_usd,
+                linesAdded: msg.total_lines_added,
+                linesRemoved: msg.total_lines_removed,
+            },
+            // 附加完整的原始对话日志
+            rawConversation: [...this.rawConversationLog],
+        };
+        // 特殊处理 max_turns
+        if (msg.subtype === "error_max_turns") {
+            result.status = "max_turns";
+        }
+        // 特殊处理限流：rate_limit_event 先于 result 到达，信息暂存在 rateLimitInfo
+        if (this.rateLimitInfo) {
+            result.status = "rate_limited";
+            result.rateLimitInfo = this.rateLimitInfo;
+            this.rateLimitInfo = null;
+        }
+        this.resultHandler?.(result);
+        this.stateChangeHandler?.(ConnectionState.CONNECTED);
+    }
+    /**
+     * 始终自动放行的工具列表（纯控制流，无安全风险）
+     */
+    static AUTO_APPROVE_TOOLS = new Set([
+        "TaskCreate",
+        "TaskUpdate",
+        "TaskList",
+        "TaskGet",
+        "SendMessage",
+    ]);
+    /**
+     * headless 模式下需要拒绝的交互式工具（需要终端用户在场）
+     */
+    static HEADLESS_DENY_TOOLS = new Set([
+        "AskUserQuestion",
+        "EnterPlanMode",
+        "ExitPlanMode",
+    ]);
+    /**
+     * 参照 companion (ws-bridge.ts:714-733 + 858-896): 工具审批流
+     */
+    async handleToolApproval(msg) {
+        const req = {
+            requestId: msg.request_id,
+            toolName: msg.request.tool_name ?? "unknown",
+            input: msg.request.input ?? {},
+            description: msg.request.description,
+            toolUseId: msg.request.tool_use_id ?? "",
+        };
+        let response;
+        if (ClaudeCodeBackend.HEADLESS_DENY_TOOLS.has(req.toolName)) {
+            // headless 模式下拒绝交互式工具
+            this.log("warn", `[审批] 拒绝交互式工具: ${req.toolName}（headless 模式无终端用户）`);
+            response = { requestId: req.requestId, behavior: "deny", reason: `${req.toolName} requires interactive terminal user, not available in headless mode. Use MCP tools (channel.send, task.dispatch, etc.) instead.` };
+        }
+        else if (ClaudeCodeBackend.AUTO_APPROVE_TOOLS.has(req.toolName)) {
+            // 安全工具自动放行，无需走 ScopeChecker
+            this.log("info", `[审批] 自动放行: ${req.toolName}`);
+            response = { requestId: req.requestId, behavior: "allow" };
+        }
+        else if (!this.toolRequestHandler) {
+            // 无 handler 时默认放行（兼容 --dangerously-skip-permissions 模式）
+            this.log("warn", `[审批] 无 handler，默认放行: ${req.toolName}`);
+            response = { requestId: req.requestId, behavior: "allow" };
+        }
+        else {
+            response = await this.toolRequestHandler(req);
+        }
+        const reply = JSON.stringify({
+            type: "control_response",
+            response: {
+                subtype: "success",
+                request_id: req.requestId,
+                response: response.behavior === "allow"
+                    ? {
+                        behavior: "allow",
+                        updatedInput: response.updatedInput ?? {},
+                    }
+                    : {
+                        behavior: "deny",
+                        message: response.reason ?? "denied by tool request handler",
+                    },
+            },
+        });
+        // 记录发出的 tool approval 响应
+        const replyMsg = JSON.parse(reply);
+        this.rawConversationLog.push({
+            direction: "sent",
+            timestamp: new Date().toISOString(),
+            message: replyMsg,
+        });
+        this.logRawMessage("sent", replyMsg);
+        // this.log(
+        //   "info",
+        //   `[WS 发] toolApproval: tool=${req.toolName}, behavior=${response.behavior}`,
+        // );
+        this.sendToCLI(reply);
+    }
+    findFreePort() {
+        return new Promise((resolve, reject) => {
+            const server = createServer();
+            server.listen(0, "127.0.0.1", () => {
+                const addr = server.address();
+                if (addr && typeof addr === "object") {
+                    const port = addr.port;
+                    server.close(() => resolve(port));
+                }
+                else {
+                    reject(new Error("Failed to get port"));
+                }
+            });
+        });
+    }
+    withTimeout(promise, ms, message) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => reject(new Error(message)), ms);
+            promise.then((val) => {
+                clearTimeout(timer);
+                resolve(val);
+            }, (err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * 从 workingDir 向上查找 git root
+     */
+    /**
+     * 将 MCP server 配置写入目标目录的 .mcp.json
+     * 如果文件已存在，合并我们的 server 条目并备份原始内容
+     */
+    writeMcpJson(workingDir, mcpServers) {
+        // 确保目录存在
+        if (!existsSync(workingDir)) {
+            mkdirSync(workingDir, { recursive: true });
+        }
+        this.mcpJsonPath = join(workingDir, ".mcp.json");
+        // 构建我们的 server 条目
+        const ourServers = {};
+        for (const s of mcpServers) {
+            if (s.url) {
+                ourServers[s.name] = {
+                    type: "http",
+                    url: s.url,
+                    ...(s.headers ? { headers: s.headers } : {}),
+                };
+            }
+            else if (s.command) {
+                ourServers[s.name] = {
+                    type: "stdio",
+                    command: s.command,
+                    ...(s.args ? { args: s.args } : {}),
+                };
+            }
+        }
+        // 读取已有文件（如有）
+        let existing = {};
+        if (existsSync(this.mcpJsonPath)) {
+            try {
+                const raw = readFileSync(this.mcpJsonPath, "utf-8");
+                existing = JSON.parse(raw);
+                this.mcpJsonBackup = raw;
+                this.mcpJsonCreated = false;
+                this.log("info", `.mcp.json 已存在，合并 ${Object.keys(ourServers).length} 个 server`);
+            }
+            catch {
+                this.mcpJsonBackup = null;
+                this.mcpJsonCreated = true;
+            }
+        }
+        else {
+            this.mcpJsonBackup = null;
+            this.mcpJsonCreated = true;
+        }
+        // 合并写入
+        const merged = {
+            ...existing,
+            mcpServers: {
+                ...(existing.mcpServers ?? {}),
+                ...ourServers,
+            },
+        };
+        writeFileSync(this.mcpJsonPath, JSON.stringify(merged, null, 2), "utf-8");
+        this.log("info", `.mcp.json 已写入: ${this.mcpJsonPath}, servers: ${Object.keys(ourServers).join(", ")}`);
+    }
+    /**
+     * 恢复或删除 .mcp.json
+     */
+    restoreMcpJson() {
+        if (!this.mcpJsonPath)
+            return;
+        try {
+            if (this.mcpJsonCreated) {
+                // 文件是我们创建的 → 直接删除
+                if (existsSync(this.mcpJsonPath)) {
+                    unlinkSync(this.mcpJsonPath);
+                    this.log("info", `.mcp.json 已删除: ${this.mcpJsonPath}`);
+                }
+            }
+            else if (this.mcpJsonBackup !== null) {
+                // 文件原本存在 → 恢复原始内容
+                writeFileSync(this.mcpJsonPath, this.mcpJsonBackup, "utf-8");
+                this.log("info", `.mcp.json 已恢复: ${this.mcpJsonPath}`);
+            }
+        }
+        catch (err) {
+            this.log("warn", `.mcp.json 清理失败:`, err.message);
+        }
+        this.mcpJsonPath = null;
+        this.mcpJsonBackup = null;
+        this.mcpJsonCreated = false;
+    }
+}
+//# sourceMappingURL=claude-code-backend.js.map