@lelouchhe/webagent 0.7.0 → 0.8.0

package/lib/routes.js

@@ -4,7 +4,7 @@ import { join, extname, basename } from "node:path";
 import { gzipSync } from "node:zlib";
 import busboy from "busboy";
 import { errorMessage, MessageIngressSchema } from "./types.js";
-import { interruptBashProc } from "./session-manager.js";
+import { interruptBashProc, InvalidSessionDirectoryError, } from "./session-manager.js";
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { handleShareRoutes } from "./share/routes.js";
@@ -22,6 +22,12 @@ import { readImageDimensions } from "./image-dimensions.js";
 import { HTTP_STATUS } from "./http-status.js";
 const IS_WIN = process.platform === "win32";
 const SAFE_ID = /^[a-zA-Z0-9_-]+$/;
+function broadcastInboxCount(store, sseManager) {
+    sseManager.broadcastGlobal({
+        type: "inbox_count_changed",
+        pendingCount: store.countUnprocessed(),
+    });
+}
 const MIME = {
     ".html": "text/html; charset=utf-8",
     ".js": "application/javascript; charset=utf-8",
@@ -736,37 +742,85 @@ export function createRequestHandler(deps) {
                     json(res, HTTP_STATUS.NOT_FOUND, { error: "Session not found" });
                     return;
                 }
-                const bridge = getBridge?.();
-                if (!bridge) {
-                    json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
-                        error: "Agent not ready yet",
-                    });
-                    return;
-                }
                 const { opId, replayed } = tryReplayClientOp(req, res, store, sessionId);
                 if (replayed)
                     return;
+                const hadAgentPrompt = sessions?.activePrompts.has(sessionId) ?? false;
+                const hadPendingPrompt = sessions?.cancelPendingPromptSubmission(sessionId) ?? false;
+                const hadBash = sessions?.runningBashProcs.has(sessionId) ?? false;
+                if (!hadAgentPrompt && !hadPendingPrompt && !hadBash) {
+                    const idleBody = { ok: true, status: "idle" };
+                    saveClientOpResult(store, opId, sessionId, HTTP_STATUS.OK, idleBody);
+                    json(res, HTTP_STATUS.OK, idleBody);
+                    return;
+                }
+                const cancelledPromptId = hadAgentPrompt
+                    ? (sessions?.state.getState(sessionId).runtime.busy?.promptId ?? null)
+                    : null;
                 // Kill running bash process if any
                 const proc = sessions?.runningBashProcs.get(sessionId);
                 if (proc) {
-                    interruptBashProc(proc);
-                    sessions.runningBashProcs.delete(sessionId);
+                    const force = sessions.interruptedBashProcs.has(proc);
+                    interruptBashProc(proc, force);
+                    sessions.interruptedBashProcs.add(proc);
                 }
-                // Cancel agent prompt
-                if (sessions?.activePrompts.has(sessionId)) {
+                const bridge = hadAgentPrompt ? getBridge?.() : null;
+                if (hadAgentPrompt && !bridge) {
+                    json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
+                        error: "Agent not ready yet",
+                    });
+                    return;
+                }
+                // ACP cancel is a notification, not an acknowledgement. Keep the
+                // prompt active until its prompt response supplies the terminal stop
+                // reason, and allow repeated requests to resend the notification.
+                if (hadAgentPrompt && sessions && bridge) {
+                    const previousCancelStatus = sessions.state.getState(sessionId).runtime.busy?.cancelStatus ??
+                        null;
+                    rlog.info("cancel requested", {
+                        sessionId: sessionId.slice(0, 8),
+                        retry: previousCancelStatus !== null,
+                        previousStatus: previousCancelStatus,
+                    });
                     await bridge.cancel(sessionId);
-                    sessions.activePrompts.delete(sessionId);
+                    const busy = sessions.state.getState(sessionId).runtime.busy;
+                    const stillCancellingSamePrompt = sessions.activePrompts.has(sessionId) &&
+                        busy?.kind === "agent" &&
+                        busy.promptId === cancelledPromptId;
+                    if (stillCancellingSamePrompt) {
+                        sessions.state.markCancelRequested(sessionId);
+                    }
                 }
-                // Arm backend safety net: if prompt_done doesn't arrive within the
-                // configured timeout, force-clear busy so the UI unstalls. Replaces
-                // the old frontend-side cancel timer.
+                // If prompt_done does not arrive, expose the lack of acknowledgement
+                // instead of pretending the prompt stopped.
                 const cancelTimeout = deps.limits.cancel_timeout ?? 0;
-                if (sessions && cancelTimeout > 0)
+                const busyAfterCancel = sessions?.state.getState(sessionId).runtime.busy;
+                const cancelPending = hadAgentPrompt &&
+                    sessions?.activePrompts.has(sessionId) === true &&
+                    busyAfterCancel?.kind === "agent" &&
+                    busyAfterCancel.promptId === cancelledPromptId;
+                if (cancelPending && cancelTimeout > 0)
                     sessions.state.armCancelSafety(sessionId, cancelTimeout);
                 sessions?.syncBusy(sessionId);
-                const okBody = { ok: true };
-                saveClientOpResult(store, opId, sessionId, HTTP_STATUS.OK, okBody);
-                json(res, HTTP_STATUS.OK, okBody);
+                const workPending = cancelPending || hadBash;
+                const replacementPromptActive = hadAgentPrompt &&
+                    ((sessions?.activePrompts.has(sessionId) === true &&
+                        busyAfterCancel?.kind === "agent" &&
+                        busyAfterCancel.promptId !== cancelledPromptId) ||
+                        sessions?.pendingPromptSubmissions.has(sessionId) === true);
+                const status = workPending || replacementPromptActive
+                    ? HTTP_STATUS.ACCEPTED
+                    : HTTP_STATUS.OK;
+                const okBody = {
+                    ok: true,
+                    status: workPending
+                        ? "cancelling"
+                        : replacementPromptActive
+                            ? "superseded"
+                            : "cancelled",
+                };
+                saveClientOpResult(store, opId, sessionId, status, okBody);
+                json(res, status, okBody);
                 return;
             }
             // --- GET /api/v1/sessions/:id/status ---
@@ -888,11 +942,43 @@ export function createRequestHandler(deps) {
                 const { opId, replayed } = tryReplayClientOp(req, res, store, sessionId);
                 if (replayed)
                     return;
+                const promptSubmissionId = sessions.reservePromptSubmission(sessionId);
+                if (promptSubmissionId === null) {
+                    const busyKind = sessions.getBusyKind(sessionId);
+                    logPromptRejectBeforeSave({
+                        sessionId,
+                        status: HTTP_STATUS.CONFLICT,
+                        reason: "session_busy",
+                        opId,
+                        busyKind: busyKind ?? undefined,
+                    });
+                    json(res, HTTP_STATUS.CONFLICT, {
+                        error: "Session is busy",
+                        busyKind,
+                    });
+                    return;
+                }
+                const requestState = { aborted: false };
+                const isRequestAborted = () => requestState.aborted;
+                const abortPromptSubmission = () => {
+                    requestState.aborted = true;
+                    sessions.releasePromptSubmission(sessionId, promptSubmissionId);
+                };
+                res.once("finish", () => {
+                    sessions.releasePromptSubmission(sessionId, promptSubmissionId);
+                });
+                req.once("aborted", abortPromptSubmission);
+                res.once("close", () => {
+                    if (!res.writableEnded)
+                        abortPromptSubmission();
+                });
                 // Ensure session is live in ACP before prompting (awaits in-flight resume)
                 try {
                     await sessions.ensureResumed(bridge, sessionId);
                 }
                 catch (err) {
+                    if (isRequestAborted())
+                        return;
                     logPromptRejectBeforeSave({
                         sessionId,
                         status: HTTP_STATUS.INTERNAL_SERVER_ERROR,
@@ -905,19 +991,16 @@ export function createRequestHandler(deps) {
                     });
                     return;
                 }
-                // Check if session is busy
-                const busyKind = sessions.getBusyKind(sessionId);
-                if (busyKind) {
+                if (isRequestAborted() ||
+                    sessions.isPromptSubmissionCancelled(promptSubmissionId)) {
                     logPromptRejectBeforeSave({
                         sessionId,
                         status: HTTP_STATUS.CONFLICT,
-                        reason: "session_busy",
+                        reason: "prompt_cancelled_before_start",
                         opId,
-                        busyKind,
                     });
                     json(res, HTTP_STATUS.CONFLICT, {
-                        error: "Session is busy",
-                        busyKind,
+                        error: "Prompt was cancelled before start",
                     });
                     return;
                 }
@@ -926,6 +1009,8 @@ export function createRequestHandler(deps) {
                     body = JSON.parse(await readBody(req));
                 }
                 catch {
+                    if (isRequestAborted())
+                        return;
                     logPromptRejectBeforeSave({
                         sessionId,
                         status: HTTP_STATUS.BAD_REQUEST,
@@ -935,6 +1020,13 @@ export function createRequestHandler(deps) {
                     json(res, HTTP_STATUS.BAD_REQUEST, { error: "Invalid JSON" });
                     return;
                 }
+                if (isRequestAborted() ||
+                    sessions.isPromptSubmissionCancelled(promptSubmissionId)) {
+                    json(res, HTTP_STATUS.CONFLICT, {
+                        error: "Prompt was cancelled before start",
+                    });
+                    return;
+                }
                 if (!body.text) {
                     logPromptRejectBeforeSave({
                         sessionId,
@@ -1057,8 +1149,10 @@ export function createRequestHandler(deps) {
                         },
                     ];
                 });
+                const eventClientOpId = opId ?? randomUUID();
                 store.saveEvent(sessionId, "user_message", {
                     text: body.text,
+                    clientOpId: eventClientOpId,
                     ...(storedAttachments?.length
                         ? { attachments: storedAttachments }
                         : {}),
@@ -1069,6 +1163,7 @@ export function createRequestHandler(deps) {
                     type: "user_message",
                     sessionId,
                     text: body.text,
+                    clientOpId: eventClientOpId,
                     attachments: storedAttachments,
                 };
                 sseManager.broadcast(userMsgEvent);
@@ -1086,14 +1181,21 @@ export function createRequestHandler(deps) {
                     });
                 }
                 // Fire prompt asynchronously (don't await — response is 202)
+                sessions.releasePromptSubmission(sessionId, promptSubmissionId, false);
                 sessions.activePrompts.add(sessionId);
                 sessions.syncBusy(sessionId);
+                const promptId = sessions.state.getState(sessionId).runtime.busy?.promptId ??
+                    undefined;
                 bridge
-                    .prompt(sessionId, agentText, attachments)
+                    .prompt(sessionId, agentText, attachments, promptId)
                     .catch((err) => {
                     plog.error("error", { sessionId, error: err });
                 })
                     .finally(() => {
+                    // A turn that outlived its own supersession must not clear the
+                    // busy state of the turn that replaced it.
+                    if (!sessions.isCurrentPrompt(sessionId, promptId))
+                        return;
                     sessions.activePrompts.delete(sessionId);
                     sessions.syncBusy(sessionId);
                 });
@@ -1460,6 +1562,12 @@ export function createRequestHandler(deps) {
                         json(res, HTTP_STATUS.NOT_FOUND, { error: "Session not found" });
                         return;
                     }
+                    if (sessions && sessions.getBusyKind(sessionId) !== null) {
+                        json(res, HTTP_STATUS.CONFLICT, {
+                            error: "Cancel active work before deleting the session",
+                        });
+                        return;
+                    }
                     if (sessions) {
                         sessions.deleteSession(sessionId);
                     }
@@ -1474,6 +1582,7 @@ export function createRequestHandler(deps) {
             }
             // POST /api/v1/sessions (create new session)
             if (url === "/api/v1/sessions" && req.method === "POST") {
+                const clientOpId = getClientOpId(req);
                 const bridge = getBridge?.();
                 if (!bridge) {
                     json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
@@ -1506,6 +1615,7 @@ export function createRequestHandler(deps) {
                         title: session?.title,
                         configOptions,
                         agentCommands: sessions.getAgentCommands(sessionId),
+                        clientOpId: clientOpId ?? undefined,
                     };
                     sseManager.broadcast(sessionCreatedEvent);
                     // ACP's session_created event fires before inheritance runs, so
@@ -1524,11 +1634,12 @@ export function createRequestHandler(deps) {
                         source: session?.source ?? source,
                         configOptions,
                         agentCommands: sessions.getAgentCommands(sessionId),
+                        clientOpId: clientOpId ?? undefined,
                     });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
-                    if (msg.includes("does not exist")) {
+                    if (err instanceof InvalidSessionDirectoryError) {
                         json(res, HTTP_STATUS.BAD_REQUEST, { error: msg });
                     }
                     else {
@@ -1563,14 +1674,15 @@ export function createRequestHandler(deps) {
                 let streamingThinking = false;
                 let streamingAssistant = false;
                 if (sessions) {
-                    if (sessions.thinkingBuffers.has(sessionId)) {
-                        streamingThinking = true;
-                        sessions.flushThinkingBuffer(sessionId);
-                    }
-                    if (sessions.assistantBuffers.has(sessionId)) {
-                        streamingAssistant = true;
-                        sessions.flushAssistantBuffer(sessionId);
-                    }
+                    const runtimeStreaming = sessions.state.peekStreaming(sessionId);
+                    streamingThinking =
+                        runtimeStreaming.thinking ||
+                            Boolean(sessions.thinkingBuffers.get(sessionId));
+                    streamingAssistant =
+                        runtimeStreaming.assistant ||
+                            Boolean(sessions.assistantBuffers.get(sessionId));
+                    sessions.flushThinkingBuffer(sessionId);
+                    sessions.flushAssistantBuffer(sessionId);
                 }
                 const events = store.getEvents(sessionId, {
                     excludeThinking,
@@ -1653,6 +1765,7 @@ export function createRequestHandler(deps) {
                     type: "connected",
                     clientId,
                     debugLevel: deps.debugLevel ?? "off",
+                    pendingCount: store.countUnprocessed(),
                 });
                 sseManager.writeHeartbeat(client);
                 return;
@@ -1696,6 +1809,7 @@ export function createRequestHandler(deps) {
                     type: "connected",
                     clientId,
                     debugLevel: deps.debugLevel ?? "off",
+                    pendingCount: store.countUnprocessed(),
                 });
                 sseManager.writeHeartbeat(client);
                 // Replay events from Last-Event-ID if provided
@@ -1906,6 +2020,7 @@ export function createRequestHandler(deps) {
                     created_at: Date.now(),
                 });
                 sseManager.broadcast({ type: "message_created", messageId: id });
+                broadcastInboxCount(store, sseManager);
                 if (deps.pushService) {
                     void deps.pushService.sendForMessage({
                         id,
@@ -1937,23 +2052,58 @@ export function createRequestHandler(deps) {
                 const consumeMatch = tail.match(/^([^/?]+)\/consume\/?$/);
                 if (consumeMatch && req.method === "POST") {
                     const id = decodeURIComponent(consumeMatch[1]);
-                    const newSid = randomUUID();
+                    let inheritFromSessionId;
+                    try {
+                        const rawBody = await readBody(req);
+                        if (rawBody) {
+                            const body = JSON.parse(rawBody);
+                            if (body.inheritFromSessionId !== undefined &&
+                                typeof body.inheritFromSessionId !== "string") {
+                                json(res, HTTP_STATUS.BAD_REQUEST, {
+                                    error: "inheritFromSessionId must be a string",
+                                });
+                                return;
+                            }
+                            inheritFromSessionId = body.inheritFromSessionId;
+                        }
+                    }
+                    catch {
+                        json(res, HTTP_STATUS.BAD_REQUEST, { error: "Invalid JSON" });
+                        return;
+                    }
+                    const bridge = getBridge?.();
+                    if (!sessions || !bridge) {
+                        json(res, HTTP_STATUS.SERVICE_UNAVAILABLE, {
+                            error: "Agent not available",
+                        });
+                        return;
+                    }
                     let out;
                     try {
-                        out = store.consumeMessageTx(id, { sessionId: newSid });
+                        out = await sessions.consumeMessage(bridge, id, inheritFromSessionId);
                     }
                     catch (err) {
-                        if (/message not found/.test(errorMessage(err))) {
-                            json(res, HTTP_STATUS.NOT_FOUND, { error: "Message not found" });
+                        if (err instanceof InvalidSessionDirectoryError) {
+                            json(res, HTTP_STATUS.BAD_REQUEST, {
+                                error: err.message,
+                            });
                             return;
                         }
-                        throw err;
+                        json(res, HTTP_STATUS.INTERNAL_SERVER_ERROR, {
+                            error: errorMessage(err),
+                        });
+                        return;
+                    }
+                    if (!out) {
+                        json(res, HTTP_STATUS.NOT_FOUND, { error: "Message not found" });
+                        return;
                     }
                     sseManager.broadcast({
                         type: "message_consumed",
                         messageId: id,
                         sessionId: out.sessionId,
                     });
+                    broadcastInboxCount(store, sseManager);
                     if (!out.alreadyConsumed && deps.pushService) {
                         void deps.pushService.sendClose(id);
                     }
@@ -1980,6 +2130,7 @@ export function createRequestHandler(deps) {
                         return;
                     }
                     sseManager.broadcast({ type: "message_acked", messageId: id });
+                    broadcastInboxCount(store, sseManager);
                     if (deps.pushService)
                         void deps.pushService.sendClose(id);
                     mlog.info("ack", { msg_id: id });
@@ -2051,10 +2202,14 @@ export function createRequestHandler(deps) {
                         sseManager.broadcast(titleEvent);
                     });
                 }
+                const betaPromptId = sessions.state.getState(sessionId).runtime.busy?.promptId ??
+                    undefined;
                 bridge
-                    .prompt(sessionId, text)
+                    .prompt(sessionId, text, undefined, betaPromptId)
                     .catch(() => { })
                     .finally(() => {
+                    if (!sessions.isCurrentPrompt(sessionId, betaPromptId))
+                        return;
                     sessions.activePrompts.delete(sessionId);
                     sessions.syncBusy(sessionId);
                 });
@@ -2233,7 +2388,7 @@ export function createRequestHandler(deps) {
             return;
         }
         // --- Static files ---
-        let staticPath = url;
+        let staticPath = url.split("?")[0] ?? url;
         const htmlEntry = HTML_ENTRYPOINTS.find((e) => e.urlPath === staticPath);
         if (htmlEntry)
             staticPath = "/" + htmlEntry.file;

package/lib/server.js

@@ -104,7 +104,9 @@ sessions.state.onPatch((event) => {
     sseManager.broadcast(event);
 });
 let bridge = null;
-let messageCleanup = null;
+const messageCleanup = startMessageCleanup(store, config.messages.unprocessed_ttl_days, (pendingCount) => {
+    sseManager.broadcastGlobal({ type: "inbox_count_changed", pendingCount });
+});
 let sharePreviewCleanup = null;
 // --- HTTP server ---
 const server = createServer((req, res) => {
@@ -153,7 +155,7 @@ async function initBridge(agentCmd) {
 async function shutdown() {
     console.log("\n[server] shutting down...");
     sseManager.stopHeartbeat();
-    messageCleanup?.stop();
+    messageCleanup.stop();
     sharePreviewCleanup?.stop();
     sessions.killAllBashProcs();
     await bridge?.shutdown();
@@ -185,7 +187,6 @@ server.listen(config.port, config.host, () => {
         // will use. If the gate ran, auth.json exists and has ≥ 1 token.
         await authStore.load();
         console.log(`[server] listening on http://localhost:${config.port}`);
-        messageCleanup = startMessageCleanup(store, config.messages.unprocessed_ttl_days);
         if (config.share.enabled) {
             sharePreviewCleanup = startSharePreviewCleanup(store);
             console.log(`[share] preview gc armed (24h interval)`);