leduo-patrol 2.2.3 → 2.2.4

package/dist/server/__tests__/acp-session.test.js

@@ -73,6 +73,29 @@ test("ClaudeAcpSession.findRestorableSession falls back to the first session whe
     const result = await session.findRestorableSession();
     assert.equal(result, "restorable-session-id");
 });
+test("ClaudeAcpSession.prompt emits prompt_started with images", async () => {
+    const events = [];
+    const session = new ClaudeAcpSession({
+        workspacePath: "/tmp/workspace",
+        agentBinPath: "claude-code-acp",
+        onEvent: (event) => events.push(event),
+    });
+    let promptPayload = null;
+    session.connection = {
+        prompt: async (payload) => {
+            promptPayload = payload;
+            return { stopReason: "end_turn" };
+        },
+    };
+    session.sessionId = "session-1";
+    session.sessionPromise = Promise.resolve("session-1");
+    session.waitForDrain = async () => undefined;
+    await session.prompt("hello", [{ data: "abc", mimeType: "image/png" }]);
+    const started = events[0];
+    assert.equal(started.type, "prompt_started");
+    assert.deepEqual(started.payload.images, [{ data: "abc", mimeType: "image/png" }]);
+    assert.deepEqual(promptPayload.prompt.map((block) => block.type), ["image", "text"]);
+});
 test("ClaudeAcpSession.connect rejects gracefully when the ACP agent spawn emits EAGAIN", async (t) => {
     const fakeChild = new EventEmitter();
     fakeChild.stdin = new PassThrough();

package/dist/server/__tests__/session-manager.test.js

@@ -1,5 +1,8 @@
 import test from "node:test";
 import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, writeFile } from "node:fs/promises";
 import { SessionManager, sessionManagerTestables } from "../session-manager.js";
 function makeSnapshot(overrides = {}) {
     return {
@@ -24,6 +27,23 @@ function makeEntry(overrides = {}) {
         acpFullTimeline: [],
         outputBuffer: "",
         switchInProgress: false,
+        acpQueueDrainActive: false,
+    };
+}
+function makeAcpState(overrides = {}) {
+    return {
+        modes: ["default"],
+        defaultModeId: "default",
+        currentModeId: "default",
+        busy: false,
+        timeline: [],
+        historyTotal: 0,
+        historyStart: 0,
+        permissions: [],
+        questions: [],
+        availableCommands: [],
+        queuedPrompts: [],
+        ...overrides,
     };
 }
 function makeManager(options) {
@@ -147,6 +167,7 @@ test("SessionManager.switchEngine rejects pending ACP approvals", async () => {
                 }],
             questions: [],
             availableCommands: [],
+            queuedPrompts: [],
         },
     }));
     manager.startEngine = async () => undefined;
@@ -171,6 +192,7 @@ test("SessionManager.switchEngine allows idle ACP sessions despite stale activit
             permissions: [],
             questions: [],
             availableCommands: [],
+            queuedPrompts: [],
         },
     }));
     manager.startEngine = async (entry, resume) => {
@@ -206,6 +228,7 @@ test("SessionManager.switchEngine allows ACP sessions after end_turn even if bus
             permissions: [],
             questions: [],
             availableCommands: [],
+            queuedPrompts: [],
         },
     }));
     manager.startEngine = async (entry, resume) => {
@@ -219,3 +242,145 @@ test("SessionManager.switchEngine allows ACP sessions after end_turn even if bus
     assert.deepEqual(stopped, ["acp"]);
     assert.deepEqual(started, [{ engine: "cli", resume: true }]);
 });
+test("SessionManager.prompt queues ACP prompts while busy", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState({ busy: true }),
+        }),
+        acpSession: {
+            setMode: async () => undefined,
+            prompt: async () => {
+                promptCalls.push("prompt");
+            },
+        },
+    });
+    await manager.prompt("s1", "queued hello");
+    const entry = manager.sessions.get("s1");
+    assert.equal(promptCalls.length, 0);
+    assert.equal(entry.snapshot.acp?.queuedPrompts.length, 1);
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.text, "queued hello");
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.status, "queued");
+    assert.equal(entry.snapshot.acp?.queuedPrompts[0]?.modeId, "default");
+});
+test("SessionManager.prompt sends immediately when ACP session is idle", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const setModeCalls = [];
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState(),
+        }),
+        acpSession: {
+            setMode: async (modeId) => {
+                setModeCalls.push(modeId);
+            },
+            prompt: async (text, images) => {
+                promptCalls.push({ text, images });
+            },
+        },
+    });
+    await manager.prompt("s1", "ship it", "plan", [{ data: "base64", mimeType: "image/png" }]);
+    const entry = manager.sessions.get("s1");
+    assert.deepEqual(setModeCalls, ["plan"]);
+    assert.deepEqual(promptCalls, [{ text: "ship it", images: [{ data: "base64", mimeType: "image/png" }] }]);
+    assert.equal(entry.snapshot.acp?.queuedPrompts.length, 0);
+});
+test("SessionManager.prompt keeps strict FIFO when queued prompts already exist", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const promptCalls = [];
+    manager.sessions.set("s1", {
+        ...makeEntry({
+            engine: "acp",
+            acp: makeAcpState({
+                queuedPrompts: [{
+                        id: "queued-1",
+                        text: "first",
+                        images: [],
+                        modeId: "default",
+                        createdAt: new Date().toISOString(),
+                        status: "queued",
+                    }],
+            }),
+        }),
+        acpSession: {
+            setMode: async () => undefined,
+            prompt: async () => {
+                promptCalls.push("prompt");
+            },
+        },
+    });
+    await manager.prompt("s1", "second");
+    const queuedPrompts = manager.sessions.get("s1").snapshot.acp?.queuedPrompts ?? [];
+    assert.equal(promptCalls.length, 1);
+    assert.deepEqual(queuedPrompts.map((prompt) => prompt.text), ["first", "second"]);
+    assert.deepEqual(queuedPrompts.map((prompt) => prompt.status), ["sending", "queued"]);
+});
+test("SessionManager.switchEngine rejects ACP sessions with queued prompts", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    manager.sessions.set("s1", makeEntry({
+        engine: "acp",
+        acp: makeAcpState({
+            queuedPrompts: [{
+                    id: "queued-1",
+                    text: "first",
+                    images: [],
+                    modeId: "default",
+                    createdAt: new Date().toISOString(),
+                    status: "queued",
+                }],
+        }),
+    }));
+    await assert.rejects(() => manager.switchEngine("s1", "cli"), /Session is not switchable: 队列未清空/);
+});
+test("SessionManager recovers persisted ACP queues and drains them on initialize", async () => {
+    const manager = makeManager({ allowedRoots: [process.cwd()], agentBinPath: "/tmp/acp" });
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), "leduo-patrol-session-manager-"));
+    const stateFilePath = path.join(tempDir, "state.json");
+    const promptCalls = [];
+    const setModeCalls = [];
+    await writeFile(stateFilePath, JSON.stringify({
+        sessions: [{
+                clientSessionId: "persisted-acp",
+                title: "persisted",
+                workspacePath: process.cwd(),
+                sessionId: "shared-session-id",
+                engine: "acp",
+                updatedAt: new Date().toISOString(),
+                acpDefaultModeId: "default",
+                acpCurrentModeId: "default",
+                acpQueuedPrompts: [{
+                        id: "queued-1",
+                        text: "resume me",
+                        images: [{ data: "abc", mimeType: "image/png" }],
+                        modeId: "plan",
+                        createdAt: new Date().toISOString(),
+                        status: "sending",
+                    }],
+            }],
+    }), "utf8");
+    manager.stateFilePath = stateFilePath;
+    manager.isRestorableWorkspace = async () => true;
+    manager.startHistoryMonitor = async () => undefined;
+    manager.startEngine = async (entry) => {
+        entry.snapshot.connectionState = "connected";
+        entry.acpSession = {
+            setMode: async (modeId) => {
+                setModeCalls.push(modeId);
+            },
+            prompt: async (text, images) => {
+                promptCalls.push({ text, images });
+            },
+        };
+        manager.recoverSendingQueuedPrompts(entry);
+        await manager.drainAcpPromptQueue(entry);
+    };
+    await manager.initialize();
+    const restoredEntry = manager.sessions.get("persisted-acp");
+    assert.deepEqual(setModeCalls, ["plan"]);
+    assert.deepEqual(promptCalls, [{ text: "resume me", images: [{ data: "abc", mimeType: "image/png" }] }]);
+    assert.equal(restoredEntry.snapshot.acp?.queuedPrompts[0]?.status, "sending");
+});

package/dist/server/acp-session.js

@@ -246,7 +246,7 @@ export class ClaudeAcpSession {
         }
         this.activePrompt = true;
         const promptId = randomUUID();
-        this.onEvent({ type: "prompt_started", payload: { promptId, text } });
+        this.onEvent({ type: "prompt_started", payload: { promptId, text, images } });
         try {
             const promptContent = [];
             if (images && images.length > 0) {

package/dist/server/index.js

@@ -232,6 +232,9 @@ wss.on("connection", (socket, request) => {
                 case "cancel":
                     await sessionManager.cancel(message.payload.clientSessionId);
                     break;
+                case "remove_queued_prompt":
+                    await sessionManager.removeQueuedPrompt(message.payload.clientSessionId, message.payload.promptId);
+                    break;
                 case "permission":
                     await sessionManager.resolvePermission(message.payload.clientSessionId, message.payload.requestId, message.payload.optionId, message.payload.note);
                     break;

package/dist/server/session-manager.js

@@ -77,7 +77,7 @@ export class SessionManager {
                 updatedAt: persisted.updatedAt,
                 allowSkipPermissions: persisted.allowSkipPermissions,
                 acp: persisted.engine === "acp"
-                    ? createEmptyAcpState(persisted.acpDefaultModeId, persisted.acpCurrentModeId)
+                    ? createEmptyAcpState(persisted.acpDefaultModeId, persisted.acpCurrentModeId, normalizeQueuedPrompts(persisted.acpQueuedPrompts))
                     : undefined,
             };
             const entry = {
@@ -88,6 +88,7 @@ export class SessionManager {
                 acpFullTimeline: [],
                 outputBuffer: "",
                 switchInProgress: false,
+                acpQueueDrainActive: false,
             };
             this.sessions.set(snapshot.clientSessionId, entry);
             if (snapshot.sessionId) {
@@ -176,6 +177,7 @@ export class SessionManager {
             acpFullTimeline: [],
             outputBuffer: "",
             switchInProgress: false,
+            acpQueueDrainActive: false,
         };
         this.sessions.set(snapshot.clientSessionId, entry);
         if (snapshot.sessionId) {
@@ -282,14 +284,21 @@ export class SessionManager {
             await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
         }
         const acpState = this.ensureAcpState(entry);
-        const effectiveModeId = modeId || acpState.defaultModeId;
-        if (effectiveModeId) {
-            await entry.acpSession?.setMode(effectiveModeId);
-            acpState.currentModeId = effectiveModeId;
+        const effectiveModeId = modeId || acpState.currentModeId || acpState.defaultModeId || "default";
+        const nextImages = images ?? [];
+        if (this.shouldQueueAcpPrompt(entry)) {
+            this.enqueueAcpPrompt(entry, text, nextImages, effectiveModeId);
+            void this.drainAcpPromptQueue(entry);
+            return;
         }
-        entry.snapshot.updatedAt = new Date().toISOString();
-        this.schedulePersist();
-        await entry.acpSession?.prompt(text, images);
+        await this.sendAcpPrompt(entry, {
+            id: randomUUID(),
+            text,
+            images: nextImages,
+            modeId: effectiveModeId,
+            createdAt: new Date().toISOString(),
+            status: "sending",
+        });
     }
     async setSessionMode(clientSessionId, modeId) {
         const entry = this.getEntry(clientSessionId);
@@ -352,6 +361,24 @@ export class SessionManager {
         }
         await entry.acpSession?.answerQuestion(questionId, answer);
     }
+    async removeQueuedPrompt(clientSessionId, promptId) {
+        const entry = this.getEntry(clientSessionId);
+        if (entry.snapshot.engine !== "acp") {
+            throw new Error("Queued prompts are only available in ACP mode.");
+        }
+        const acpState = this.ensureAcpState(entry);
+        const prompt = acpState.queuedPrompts.find((item) => item.id === promptId);
+        if (!prompt) {
+            return;
+        }
+        if (prompt.status === "sending") {
+            throw new Error("Queued prompt is currently sending and cannot be removed.");
+        }
+        acpState.queuedPrompts = acpState.queuedPrompts.filter((item) => item.id !== promptId);
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.emitSessionUpdated(entry);
+    }
     async closeSession(clientSessionId) {
         const entry = this.sessions.get(clientSessionId);
         if (!entry) {
@@ -368,6 +395,112 @@ export class SessionManager {
             payload: { clientSessionId },
         });
     }
+    shouldQueueAcpPrompt(entry) {
+        const acpState = this.ensureAcpState(entry);
+        return (entry.acpQueueDrainActive
+            || acpState.queuedPrompts.length > 0
+            || acpState.permissions.length > 0
+            || acpState.questions.length > 0
+            || this.isAcpBusy(acpState));
+    }
+    enqueueAcpPrompt(entry, text, images, modeId) {
+        const acpState = this.ensureAcpState(entry);
+        acpState.queuedPrompts.push({
+            id: randomUUID(),
+            text,
+            images,
+            modeId,
+            createdAt: new Date().toISOString(),
+            status: "queued",
+        });
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        this.emitSessionUpdated(entry);
+    }
+    async sendAcpPrompt(entry, prompt) {
+        if (!entry.acpSession) {
+            await this.startEngine(entry, Boolean(entry.snapshot.sessionId));
+        }
+        const acpState = this.ensureAcpState(entry);
+        if (prompt.modeId) {
+            await entry.acpSession?.setMode(prompt.modeId);
+            acpState.currentModeId = prompt.modeId;
+        }
+        entry.snapshot.updatedAt = new Date().toISOString();
+        this.schedulePersist();
+        await entry.acpSession?.prompt(prompt.text, prompt.images);
+    }
+    canDrainAcpPromptQueue(entry) {
+        if (entry.snapshot.engine !== "acp" || entry.snapshot.connectionState !== "connected") {
+            return false;
+        }
+        if (!entry.acpSession || entry.acpQueueDrainActive) {
+            return false;
+        }
+        const acpState = this.ensureAcpState(entry);
+        return (acpState.permissions.length === 0
+            && acpState.questions.length === 0
+            && !this.isAcpBusy(acpState)
+            && acpState.queuedPrompts.length > 0);
+    }
+    async drainAcpPromptQueue(entry) {
+        if (!this.canDrainAcpPromptQueue(entry)) {
+            return;
+        }
+        const acpState = this.ensureAcpState(entry);
+        const nextPrompt = acpState.queuedPrompts[0];
+        if (!nextPrompt) {
+            return;
+        }
+        const drainingPromptId = nextPrompt.id;
+        entry.acpQueueDrainActive = true;
+        try {
+            if (nextPrompt.status !== "sending") {
+                nextPrompt.status = "sending";
+                entry.snapshot.updatedAt = new Date().toISOString();
+                this.schedulePersist();
+                this.emitSessionUpdated(entry);
+            }
+            await this.sendAcpPrompt(entry, nextPrompt);
+        }
+        catch (error) {
+            if (!isAcpPromptBusyError(error)) {
+                this.handleManagerError(entry.snapshot.clientSessionId, error);
+            }
+        }
+        finally {
+            entry.acpQueueDrainActive = false;
+            if (this.canDrainAcpPromptQueue(entry) && this.ensureAcpState(entry).queuedPrompts[0]?.id !== drainingPromptId) {
+                void this.drainAcpPromptQueue(entry);
+            }
+        }
+    }
+    recoverSendingQueuedPrompts(entry) {
+        const acpState = this.ensureAcpState(entry);
+        if (acpState.queuedPrompts.length === 0) {
+            return false;
+        }
+        let changed = false;
+        const canResumeQueueHead = acpState.permissions.length === 0
+            && acpState.questions.length === 0
+            && !this.isAcpBusy(acpState);
+        acpState.queuedPrompts = acpState.queuedPrompts.map((prompt, index) => {
+            if (prompt.status !== "sending") {
+                return prompt;
+            }
+            if (index === 0 && canResumeQueueHead) {
+                changed = true;
+                return { ...prompt, status: "queued" };
+            }
+            return prompt;
+        });
+        if (changed) {
+            entry.snapshot.updatedAt = new Date().toISOString();
+            this.schedulePersist();
+            this.emitSessionUpdated(entry);
+        }
+        return changed;
+    }
     async startEngine(entry, resume) {
         entry.snapshot.connectionState = "connecting";
         entry.snapshot.updatedAt = new Date().toISOString();
@@ -379,6 +512,7 @@ export class SessionManager {
         await this.startAcpSession(entry, resume);
     }
     async stopEngine(entry, reason) {
+        entry.acpQueueDrainActive = false;
         if (reason === "switch") {
             entry.outputBuffer = "";
         }
@@ -480,6 +614,8 @@ export class SessionManager {
         entry.snapshot.connectionState = "connected";
         entry.snapshot.updatedAt = new Date().toISOString();
         this.schedulePersist();
+        this.recoverSendingQueuedPrompts(entry);
+        void this.drainAcpPromptQueue(entry);
     }
     handleAcpSessionEvent(clientSessionId, event) {
         const entry = this.sessions.get(clientSessionId);
@@ -534,14 +670,19 @@ export class SessionManager {
                     kind: "user",
                     title: "你",
                     body: event.payload.text,
+                    images: event.payload.images,
                 });
                 break;
             case "prompt_finished":
-                acpState.busy = false;
+                acpState.busy = shouldKeepAcpSessionRunningAfterPromptFinished(event.payload.stopReason);
+                if (acpState.queuedPrompts[0]?.status === "sending") {
+                    acpState.queuedPrompts.shift();
+                    shouldEmitFullSnapshot = true;
+                }
                 this.appendTimeline(entry, {
                     id: randomUUID(),
                     kind: "system",
-                    title: "本轮完成",
+                    title: acpState.busy ? "等待待处理中" : "本轮完成",
                     body: event.payload.stopReason,
                 });
                 break;
@@ -733,6 +874,7 @@ export class SessionManager {
                         clientSessionId,
                         promptId: event.payload.promptId,
                         text: event.payload.text,
+                        images: event.payload.images,
                     },
                 });
                 break;
@@ -824,6 +966,9 @@ export class SessionManager {
             default:
                 break;
         }
+        if (event.type === "prompt_finished" || event.type === "permission_resolved" || event.type === "question_answered") {
+            void this.drainAcpPromptQueue(entry);
+        }
     }
     consumeSessionUpdate(entry, update) {
         const acpState = this.ensureAcpState(entry);
@@ -984,6 +1129,8 @@ export class SessionManager {
             return "待提问";
         if (this.isAcpBusy(acpState))
             return "运行中";
+        if (acpState.queuedPrompts.length > 0)
+            return "队列未清空";
         return null;
     }
     isAcpBusy(acpState) {
@@ -1016,6 +1163,7 @@ export class SessionManager {
             allowSkipPermissions: session.allowSkipPermissions,
             acpDefaultModeId: session.acp?.defaultModeId,
             acpCurrentModeId: session.acp?.currentModeId,
+            acpQueuedPrompts: session.acp?.queuedPrompts ?? [],
         }));
         await mkdir(path.dirname(this.stateFilePath), { recursive: true });
         await writeFile(this.stateFilePath, JSON.stringify({ sessions: persistedSessions }, null, 2), "utf8");
@@ -1300,7 +1448,7 @@ export class SessionManager {
         });
     }
 }
-function createEmptyAcpState(defaultModeId = "default", currentModeId = defaultModeId) {
+function createEmptyAcpState(defaultModeId = "default", currentModeId = defaultModeId, queuedPrompts = []) {
     return {
         modes: [],
         defaultModeId,
@@ -1312,8 +1460,44 @@ function createEmptyAcpState(defaultModeId = "default", currentModeId = defaultM
         permissions: [],
         questions: [],
         availableCommands: [],
+        queuedPrompts,
     };
 }
+function normalizeQueuedPrompts(rawQueuedPrompts) {
+    if (!Array.isArray(rawQueuedPrompts)) {
+        return [];
+    }
+    return rawQueuedPrompts.flatMap((rawPrompt) => {
+        const record = asRecord(rawPrompt);
+        if (!record) {
+            return [];
+        }
+        const id = typeof record.id === "string" && record.id.trim() ? record.id : randomUUID();
+        const text = typeof record.text === "string" ? record.text : "";
+        const images = Array.isArray(record.images)
+            ? record.images.flatMap((rawImage) => {
+                const image = asRecord(rawImage);
+                if (!image || typeof image.data !== "string" || typeof image.mimeType !== "string") {
+                    return [];
+                }
+                return [{ data: image.data, mimeType: image.mimeType }];
+            })
+            : [];
+        const modeId = typeof record.modeId === "string" && record.modeId.trim() ? record.modeId : "default";
+        const createdAt = typeof record.createdAt === "string" && record.createdAt.trim()
+            ? record.createdAt
+            : new Date().toISOString();
+        const status = record.status === "sending" ? "sending" : "queued";
+        return [{ id, text, images, modeId, createdAt, status }];
+    });
+}
+function shouldKeepAcpSessionRunningAfterPromptFinished(stopReason) {
+    const normalized = stopReason.trim().toLowerCase();
+    return normalized === "pause_turn" || normalized === "pause-turn" || normalized.includes("permission");
+}
+function isAcpPromptBusyError(error) {
+    return error instanceof Error && error.message.includes("Another Claude prompt is still running.");
+}
 function stringifyMaybe(value) {
     if (typeof value === "string") {
         return value;