leduo-patrol 1.0.0

package/dist/server/acp-session.js

@@ -0,0 +1,300 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+export class ClaudeAcpSession {
+    workspacePath;
+    agentBinPath;
+    onEvent;
+    pendingPermissions = new Map();
+    agentProcess = null;
+    connection = null;
+    sessionId = null;
+    activePrompt = false;
+    connectPromise = null;
+    sessionPromise = null;
+    currentModeId = null;
+    constructor(options) {
+        this.workspacePath = options.workspacePath;
+        this.agentBinPath = options.agentBinPath;
+        this.onEvent = options.onEvent;
+    }
+    async connect() {
+        if (this.connectPromise) {
+            await this.connectPromise;
+            return;
+        }
+        if (this.connection) {
+            this.emitReady();
+            return;
+        }
+        this.connectPromise = (async () => {
+            await mkdir(this.workspacePath, { recursive: true });
+            this.agentProcess = spawn(this.agentBinPath, [], {
+                cwd: this.workspacePath,
+                env: process.env,
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            this.agentProcess.stderr.on("data", (chunk) => {
+                const message = chunk.toString().trim();
+                if (!message || this.shouldIgnoreAgentStderr(message) || this.shouldIgnoreToolOutputLog(message)) {
+                    return;
+                }
+                this.onEvent({ type: "error", payload: { message } });
+            });
+            this.agentProcess.on("exit", (code, signal) => {
+                this.connection = null;
+                this.sessionId = null;
+                this.sessionPromise = null;
+                this.connectPromise = null;
+                this.activePrompt = false;
+                this.rejectPendingPermissions(new Error("Permission request cancelled because ACP agent exited."));
+                this.onEvent({
+                    type: "error",
+                    payload: { message: `Claude ACP agent exited (${code ?? "null"} / ${signal ?? "null"}).` },
+                });
+            });
+            const input = Writable.toWeb(this.agentProcess.stdin);
+            const output = Readable.toWeb(this.agentProcess.stdout);
+            const stream = acp.ndJsonStream(input, output);
+            const client = {
+                requestPermission: async (params) => this.handlePermissionRequest(params),
+                sessionUpdate: async (params) => {
+                    this.onEvent({ type: "session_update", payload: params.update });
+                },
+                readTextFile: async (params) => {
+                    const filePath = this.resolveWorkspacePath(params.path);
+                    const content = await readFile(filePath, "utf8");
+                    return { content };
+                },
+                writeTextFile: async (params) => {
+                    const filePath = this.resolveWorkspacePath(params.path);
+                    await mkdir(path.dirname(filePath), { recursive: true });
+                    await writeFile(filePath, params.content, "utf8");
+                    return {};
+                },
+            };
+            this.connection = new acp.ClientSideConnection(() => client, stream);
+            await this.connection.initialize({
+                protocolVersion: acp.PROTOCOL_VERSION,
+                clientCapabilities: {
+                    fs: {
+                        readTextFile: true,
+                        writeTextFile: true,
+                    },
+                },
+            });
+            this.emitReady();
+        })();
+        try {
+            await this.connectPromise;
+        }
+        catch (error) {
+            this.connectPromise = null;
+            throw error;
+        }
+    }
+    async ensureSession() {
+        if (this.sessionPromise) {
+            return await this.sessionPromise;
+        }
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (this.sessionId || !this.connection) {
+            return this.sessionId;
+        }
+        this.sessionPromise = (async () => {
+            const response = await this.connection.newSession({
+                cwd: this.workspacePath,
+                mcpServers: [],
+            });
+            this.sessionId = response.sessionId;
+            this.currentModeId = null;
+            this.onEvent({
+                type: "session_created",
+                payload: {
+                    sessionId: response.sessionId,
+                    modes: response.modes?.availableModes.map((mode) => mode.id) ?? [],
+                    configOptions: response.configOptions ?? [],
+                },
+            });
+            return this.sessionId;
+        })();
+        try {
+            return await this.sessionPromise;
+        }
+        catch (error) {
+            this.sessionPromise = null;
+            throw error;
+        }
+    }
+    async loadSession(existingSessionId) {
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (!this.connection) {
+            throw new Error("ACP connection is not available.");
+        }
+        this.sessionId = existingSessionId;
+        this.sessionPromise = Promise.resolve(existingSessionId);
+        const response = await this.connection.loadSession({
+            sessionId: existingSessionId,
+            cwd: this.workspacePath,
+            mcpServers: [],
+        });
+        this.currentModeId = response.modes?.currentModeId ?? null;
+        this.onEvent({
+            type: "session_restored",
+            payload: {
+                sessionId: existingSessionId,
+                modes: response.modes?.availableModes.map((mode) => mode.id) ?? [],
+                configOptions: response.configOptions ?? [],
+            },
+        });
+        return existingSessionId;
+    }
+    async findRestorableSession(preferredSessionId) {
+        if (!this.connection) {
+            await this.connect();
+        }
+        if (!this.connection) {
+            throw new Error("ACP connection is not available.");
+        }
+        const response = await this.connection.unstable_listSessions({
+            cwd: this.workspacePath,
+        });
+        if (preferredSessionId) {
+            const exactMatch = response.sessions.find((session) => session.sessionId === preferredSessionId);
+            if (exactMatch) {
+                return exactMatch.sessionId;
+            }
+        }
+        return response.sessions[0]?.sessionId ?? null;
+    }
+    async prompt(text, images) {
+        const sessionId = await this.ensureSession();
+        if (!this.connection || !sessionId) {
+            throw new Error("ACP session is not available.");
+        }
+        if (this.activePrompt) {
+            throw new Error("Another Claude prompt is still running.");
+        }
+        this.activePrompt = true;
+        const promptId = randomUUID();
+        this.onEvent({ type: "prompt_started", payload: { promptId, text } });
+        try {
+            // Images first, then text — mirrors the convention used by Claude's own clients
+            // (vision context before the instruction yields better results).
+            const promptContent = [];
+            if (images && images.length > 0) {
+                for (const img of images) {
+                    promptContent.push({ type: "image", data: img.data, mimeType: img.mimeType });
+                }
+            }
+            promptContent.push({ type: "text", text });
+            const response = await this.connection.prompt({
+                sessionId,
+                messageId: randomUUID(),
+                prompt: promptContent,
+            });
+            this.onEvent({
+                type: "prompt_finished",
+                payload: { promptId, stopReason: response.stopReason },
+            });
+        }
+        finally {
+            this.activePrompt = false;
+        }
+    }
+    async setMode(modeId) {
+        const sessionId = await this.ensureSession();
+        if (!this.connection || !sessionId || !modeId || this.currentModeId === modeId) {
+            return;
+        }
+        await this.connection.setSessionMode({
+            sessionId,
+            modeId,
+        });
+        this.currentModeId = modeId;
+    }
+    async cancel() {
+        if (!this.connection || !this.sessionId || !this.activePrompt) {
+            return;
+        }
+        await this.connection.cancel({ sessionId: this.sessionId });
+    }
+    async resolvePermission(requestId, optionId, note) {
+        const pending = this.pendingPermissions.get(requestId);
+        if (!pending) {
+            throw new Error("Permission request was not found or already resolved.");
+        }
+        pending.resolve({
+            outcome: {
+                outcome: "selected",
+                optionId,
+                _meta: note && note.trim() ? { note: note.trim() } : undefined,
+            },
+        });
+        this.pendingPermissions.delete(requestId);
+        this.onEvent({ type: "permission_resolved", payload: { requestId, optionId } });
+    }
+    async dispose() {
+        this.rejectPendingPermissions(new Error("Client disconnected."));
+        if (this.agentProcess && !this.agentProcess.killed) {
+            this.agentProcess.kill();
+        }
+        this.agentProcess = null;
+        this.connection = null;
+        this.sessionId = null;
+        this.sessionPromise = null;
+        this.connectPromise = null;
+        this.currentModeId = null;
+        this.activePrompt = false;
+    }
+    emitReady() {
+        this.onEvent({
+            type: "ready",
+            payload: { workspacePath: this.workspacePath, agentConnected: true },
+        });
+    }
+    shouldIgnoreAgentStderr(message) {
+        return (message.includes("Error handling notification") &&
+            message.includes("method: 'session/update'") &&
+            message.includes("message: 'Invalid params'"));
+    }
+    shouldIgnoreToolOutputLog(message) {
+        const normalized = message.trim();
+        return normalized.startsWith('[{"index":') || normalized.startsWith("[{\"index\":");
+    }
+    async handlePermissionRequest(params) {
+        const requestId = randomUUID();
+        this.onEvent({
+            type: "permission_requested",
+            payload: {
+                requestId,
+                toolCall: params.toolCall,
+                options: params.options,
+            },
+        });
+        return await new Promise((resolve, reject) => {
+            this.pendingPermissions.set(requestId, { resolve, reject });
+        });
+    }
+    rejectPendingPermissions(reason) {
+        for (const pending of this.pendingPermissions.values()) {
+            pending.reject(reason);
+        }
+        this.pendingPermissions.clear();
+    }
+    resolveWorkspacePath(targetPath) {
+        const absolutePath = path.resolve(this.workspacePath, targetPath);
+        const relativePath = path.relative(this.workspacePath, absolutePath);
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error(`Refusing to access file outside workspace: ${targetPath}`);
+        }
+        return absolutePath;
+    }
+}

package/dist/server/git-diff.js

@@ -0,0 +1,124 @@
+import { access, constants } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import path from "node:path";
+const execFileAsync = promisify(execFile);
+const DIFF_TOO_LARGE_THRESHOLD_BYTES = Number(process.env.LEDUO_PATROL_MAX_DIFF_FILE_BYTES ?? 200 * 1024);
+export async function buildWorkspaceDiffFilesSnapshot(workspacePath) {
+    const repositoryRoot = await resolveRepositoryRoot(workspacePath);
+    const statusOutput = await runGit(repositoryRoot, ["status", "--porcelain", "--", "."]);
+    const parsed = parsePorcelainStatus(statusOutput);
+    return {
+        workspacePath,
+        workspaceReadonly: await detectReadonly(workspacePath),
+        repositoryRoot,
+        workingTree: parsed.workingTree,
+        staged: parsed.staged,
+        untracked: parsed.untracked,
+    };
+}
+export async function buildSingleFileDiff(workspacePath, category, filePath) {
+    const repositoryRoot = await resolveRepositoryRoot(workspacePath);
+    const normalizedPath = filePath.trim();
+    if (!normalizedPath) {
+        throw new Error("filePath is required");
+    }
+    const diff = category === "workingTree"
+        ? await runGit(repositoryRoot, ["diff", "--no-color", "--", normalizedPath])
+        : category === "staged"
+            ? await runGit(repositoryRoot, ["diff", "--cached", "--no-color", "--", normalizedPath])
+            : await runDiffForUntrackedFile(repositoryRoot, normalizedPath);
+    if (Buffer.byteLength(diff, "utf8") > DIFF_TOO_LARGE_THRESHOLD_BYTES) {
+        return {
+            category,
+            filePath: normalizedPath,
+            omitted: true,
+            diff: "",
+            reason: `该文件 Diff 过大（>${Math.round(DIFF_TOO_LARGE_THRESHOLD_BYTES / 1024)}KB），已省略显示。`,
+        };
+    }
+    return {
+        category,
+        filePath: normalizedPath,
+        omitted: false,
+        diff,
+    };
+}
+async function detectReadonly(workspacePath) {
+    try {
+        await access(workspacePath, constants.W_OK);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+async function resolveRepositoryRoot(workspacePath) {
+    const output = await runGit(workspacePath, ["rev-parse", "--show-toplevel"]);
+    const root = output.trim();
+    if (!root) {
+        throw new Error("当前目录不是 Git 仓库。");
+    }
+    return root;
+}
+async function runGit(cwd, args) {
+    const { stdout } = await execFileAsync("git", args, {
+        cwd,
+        env: process.env,
+        maxBuffer: 20 * 1024 * 1024,
+    });
+    return stdout;
+}
+async function runDiffForUntrackedFile(cwd, relativePath) {
+    const absolutePath = path.join(cwd, relativePath);
+    try {
+        return await runGit(cwd, ["diff", "--no-index", "--no-color", "/dev/null", absolutePath]);
+    }
+    catch (error) {
+        if (isExpectedNoIndexExit(error)) {
+            return error.stdout;
+        }
+        throw error;
+    }
+}
+function isExpectedNoIndexExit(error) {
+    return !!error && typeof error === "object" && "code" in error && error.code === 1 && "stdout" in error;
+}
+function parsePorcelainStatus(statusOutput) {
+    const workingTree = new Set();
+    const staged = new Set();
+    const untracked = new Set();
+    for (const rawLine of statusOutput.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (!line) {
+            continue;
+        }
+        const statusCode = line.slice(0, 2);
+        const pathText = normalizeStatusPath(line.slice(3).trim());
+        if (!pathText) {
+            continue;
+        }
+        if (statusCode === "??") {
+            untracked.add(pathText);
+            continue;
+        }
+        const stagedCode = statusCode[0] ?? " ";
+        const workingCode = statusCode[1] ?? " ";
+        if (stagedCode !== " ") {
+            staged.add(pathText);
+        }
+        if (workingCode !== " ") {
+            workingTree.add(pathText);
+        }
+    }
+    return {
+        workingTree: [...workingTree].sort((a, b) => a.localeCompare(b)).map((filePath) => ({ filePath, changeType: "修改" })),
+        staged: [...staged].sort((a, b) => a.localeCompare(b)).map((filePath) => ({ filePath, changeType: "修改" })),
+        untracked: [...untracked].sort((a, b) => a.localeCompare(b)).map((filePath) => ({ filePath, changeType: "新增" })),
+    };
+}
+function normalizeStatusPath(pathText) {
+    const renameMarker = " -> ";
+    const renamedTo = pathText.includes(renameMarker) ? pathText.split(renameMarker).at(-1) : pathText;
+    return (renamedTo ?? "").trim();
+}