chapterhouse 0.11.1 → 0.11.3

package/dist/api/routes/agents.js

@@ -268,10 +268,6 @@ export function createAgentsRouter(options) {
         res.setHeader("Connection", "keep-alive");
         res.setHeader("X-Accel-Buffering", "no");
         res.flushHeaders();
-        const rawLastId = req.headers["last-event-id"];
-        const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
-            ? parseInt(rawLastId.trim(), 10)
-            : undefined;
         const sendEvent = (event) => {
             let payload;
             if (event.kind === "output_delta") {
@@ -303,41 +299,48 @@ export function createAgentsRouter(options) {
             }
             res.write(`id: ${event.seq}\ndata: ${JSON.stringify(payload)}\n\n`);
         };
-        let replayHighSeq = lastSeq;
-        if (lastSeq !== undefined) {
-            const bufferedEvents = getTaskLogEvents(taskId);
-            const oldestBufferedSeq = bufferedEvents[0]?.seq;
-            const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
-            if (bufferMissesRange) {
-                const dbEvents = getTaskEvents(taskId, lastSeq);
-                for (const event of dbEvents) {
-                    sendEvent(event);
-                    if (replayHighSeq === undefined || event.seq > replayHighSeq) {
-                        replayHighSeq = event.seq;
-                    }
-                }
-            }
-        }
-        const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
-        const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
-        for (const event of backlog) {
-            sendEvent(event);
-        }
         const isTerminal = () => {
             const row = getDb()
                 .prepare(`SELECT status FROM agent_tasks WHERE task_id = ?`)
                 .get(taskId);
             return row ? TERMINAL_TASK_STATUSES.has(row.status) : true;
         };
-        res.write(`: connected task=${taskId}\n\n`);
-        if (isTerminal()) {
-            res.end();
-            return;
-        }
-        const heartbeat = setInterval(() => {
-            res.write(`: keep-alive\n\n`);
-        }, 15_000);
         setupSseCleanup((registerCleanup, cleanupNow) => {
+            req.on("close", cleanupNow);
+            res.on("close", cleanupNow);
+            res.on("error", cleanupNow);
+            const rawLastId = req.headers["last-event-id"];
+            const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+                ? parseInt(rawLastId.trim(), 10)
+                : undefined;
+            let replayHighSeq = lastSeq;
+            if (lastSeq !== undefined) {
+                const bufferedEvents = getTaskLogEvents(taskId);
+                const oldestBufferedSeq = bufferedEvents[0]?.seq;
+                const bufferMissesRange = oldestBufferedSeq === undefined || oldestBufferedSeq > lastSeq + 1;
+                if (bufferMissesRange) {
+                    const dbEvents = getTaskEvents(taskId, lastSeq);
+                    for (const event of dbEvents) {
+                        sendEvent(event);
+                        if (replayHighSeq === undefined || event.seq > replayHighSeq) {
+                            replayHighSeq = event.seq;
+                        }
+                    }
+                }
+            }
+            const replayEvents = getTaskLogEvents(taskId, replayHighSeq ?? 0);
+            const backlog = replayEvents.length > 0 ? replayEvents : getTaskEvents(taskId, replayHighSeq ?? 0);
+            for (const event of backlog) {
+                sendEvent(event);
+            }
+            res.write(`: connected task=${taskId}\n\n`);
+            if (isTerminal()) {
+                res.end();
+                return;
+            }
+            const heartbeat = setInterval(() => {
+                res.write(`: keep-alive\n\n`);
+            }, 15_000);
             registerCleanup(() => clearInterval(heartbeat));
             registerCleanup(subscribeTaskLog(taskId, (event) => {
                 sendEvent(event);
@@ -359,7 +362,6 @@ export function createAgentsRouter(options) {
                     res.end();
                 }
             }));
-            req.on("close", cleanupNow);
         });
     });
     // ---------------------------------------------------------------------------
@@ -370,19 +372,21 @@ export function createAgentsRouter(options) {
     // Chat-specific events (delta, message, queued) are NOT emitted here.
     // ---------------------------------------------------------------------------
     router.get("/api/agents/stream", (req, res) => {
-        res.writeHead(200, {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-        });
-        res.write(formatSseData({ type: "connected" }));
-        const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
         setupSseCleanup((registerCleanup, cleanupNow) => {
+            req.on("close", cleanupNow);
+            res.on("close", cleanupNow);
+            res.on("error", cleanupNow);
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            res.write(formatSseData({ type: "connected" }));
+            const heartbeat = setInterval(() => { res.write(`:ping\n\n`); }, 20_000);
             registerCleanup(() => clearInterval(heartbeat));
             registerCleanup(agentEventBus.subscribeAll((event) => {
                 res.write(formatSseData({ type: "agent_event", agentEvent: event }));
             }));
-            req.on("close", cleanupNow);
         });
     });
     router.post("/api/agents/:slug/reload-confirm", async (req, res) => {

package/dist/api/routes/sessions.js

@@ -10,7 +10,7 @@ import { BadRequestError, parseRequest } from "../errors.js";
 import { sendJson } from "../send-json.js";
 import { formatSseData } from "../sse.js";
 import { setupSseCleanup } from "../server-runtime.js";
-import { associateSseClient, broadcastSsePayload, nextSseConnectionId, pendingSseMessages, sseClients, } from "../sse-hub.js";
+import { associateSseClient, broadcastSsePayload, drainPendingSseMessages, nextSseConnectionId, sseClients, } from "../sse-hub.js";
 const requiredString = (message) => z.string({ error: message }).trim().min(1, message);
 const messageRequestSchema = z.object({
     prompt: requiredString("Missing 'prompt' in request body"),
@@ -46,37 +46,35 @@ export function createSessionsRouter() {
     const router = Router();
     router.get("/stream", (req, res) => {
         const connectionId = nextSseConnectionId();
-        res.writeHead(200, {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive",
-        });
-        res.write(formatSseData({ type: "connected", connectionId }));
-        while (pendingSseMessages.length > 0) {
-            const queued = pendingSseMessages.shift();
-            if (!queued) {
-                continue;
-            }
-            res.write(formatSseData({ type: "message", content: queued }));
-        }
-        sseClients.set(connectionId, { res, sessionKey: null });
-        const unsubscribeStatus = onStatusChange((status, message) => {
-            res.write(formatSseData({ type: "status", status, message }));
-        });
-        const currentStatus = getStatus();
-        if (currentStatus.status !== "idle") {
-            res.write(formatSseData({ type: "status", ...currentStatus }));
-        }
-        const heartbeat = setInterval(() => {
-            res.write(`:ping\n\n`);
-        }, 20_000);
         setupSseCleanup((registerCleanup, cleanupNow) => {
-            registerCleanup(() => clearInterval(heartbeat));
-            registerCleanup(unsubscribeStatus);
+            req.on("close", cleanupNow);
+            res.on("close", cleanupNow);
+            res.on("error", cleanupNow);
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            sseClients.set(connectionId, { res, sessionKey: null });
             registerCleanup(() => {
                 sseClients.delete(connectionId);
             });
-            req.on("close", cleanupNow);
+            const unsubscribeStatus = onStatusChange((status, message) => {
+                res.write(formatSseData({ type: "status", status, message }));
+            });
+            registerCleanup(unsubscribeStatus);
+            const heartbeat = setInterval(() => {
+                res.write(`:ping\n\n`);
+            }, 20_000);
+            registerCleanup(() => clearInterval(heartbeat));
+            res.write(formatSseData({ type: "connected", connectionId }));
+            for (const queued of drainPendingSseMessages()) {
+                res.write(formatSseData({ type: "message", content: queued.content }));
+            }
+            const currentStatus = getStatus();
+            if (currentStatus.status !== "idle") {
+                res.write(formatSseData({ type: "status", ...currentStatus }));
+            }
         });
     });
     // ---------------------------------------------------------------------------
@@ -266,40 +264,43 @@ export function createSessionsRouter() {
             res.setHeader("Connection", "keep-alive");
             res.setHeader("X-Accel-Buffering", "no");
             res.flushHeaders();
-            // Parse Last-Event-ID for reconnect replay
-            const rawLastId = req.headers["last-event-id"];
-            const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
-                ? parseInt(rawLastId.trim(), 10)
-                : undefined;
-            const maxCurrentSeq = getSessionMaxSeqFromDb(sessionKey, { includeHistorical });
-            const effectiveLastSeq = maxCurrentSeq !== undefined && lastSeq !== undefined && lastSeq > maxCurrentSeq
-                ? 0
-                : lastSeq;
             // Helper: send a named SSE event with an id: field
             const sendEvent = (event, seq) => {
                 const payload = JSON.stringify(event);
                 res.write(`id: ${seq}\ndata: ${payload}\n\n`);
             };
-            // If Last-Event-ID is present and the session ring buffer doesn't cover it,
-            // fall back to SQLite for replay of completed turns.
-            let replayHighSeq = effectiveLastSeq;
-            if (effectiveLastSeq !== undefined) {
-                const oldestBuf = oldestSessionSeq(sessionKey);
-                const bufferMissesRange = oldestBuf === undefined || oldestBuf > effectiveLastSeq + 1;
-                if (bufferMissesRange) {
-                    // Replay from SQLite (completed turns)
-                    const dbEvents = getSessionEventsFromDb(sessionKey, effectiveLastSeq, { includeHistorical });
-                    for (const e of dbEvents) {
-                        sendEvent(e, e._seq);
-                        if (replayHighSeq === undefined || e._seq > replayHighSeq)
-                            replayHighSeq = e._seq;
+            setupSseCleanup((registerCleanup, cleanupNow) => {
+                req.on("close", cleanupNow);
+                res.on("close", cleanupNow);
+                res.on("error", cleanupNow);
+                // Parse Last-Event-ID for reconnect replay
+                const rawLastId = req.headers["last-event-id"];
+                const lastSeq = rawLastId && !Array.isArray(rawLastId) && /^\d+$/.test(rawLastId.trim())
+                    ? parseInt(rawLastId.trim(), 10)
+                    : undefined;
+                const maxCurrentSeq = getSessionMaxSeqFromDb(sessionKey, { includeHistorical });
+                const effectiveLastSeq = maxCurrentSeq !== undefined && lastSeq !== undefined && lastSeq > maxCurrentSeq
+                    ? 0
+                    : lastSeq;
+                // If Last-Event-ID is present and the session ring buffer doesn't cover it,
+                // fall back to SQLite for replay of completed turns.
+                let replayHighSeq = effectiveLastSeq;
+                if (effectiveLastSeq !== undefined) {
+                    const oldestBuf = oldestSessionSeq(sessionKey);
+                    const bufferMissesRange = oldestBuf === undefined || oldestBuf > effectiveLastSeq + 1;
+                    if (bufferMissesRange) {
+                        // Replay from SQLite (completed turns)
+                        const dbEvents = getSessionEventsFromDb(sessionKey, effectiveLastSeq, { includeHistorical });
+                        for (const e of dbEvents) {
+                            sendEvent(e, e._seq);
+                            if (replayHighSeq === undefined || e._seq > replayHighSeq)
+                                replayHighSeq = e._seq;
+                        }
                     }
                 }
-            }
-            // Subscribe to session events (replays ring buffer for afterSeq, then live).
-            // Use replayHighSeq (not lastSeq) so ring-buffer replay starts after any DB
-            // events we already sent — avoids double-replay overlap (Fix 5).
-            setupSseCleanup((registerCleanup, cleanupNow) => {
+                // Subscribe to session events (replays ring buffer for afterSeq, then live).
+                // Use replayHighSeq (not lastSeq) so ring-buffer replay starts after any DB
+                // events we already sent — avoids double-replay overlap (Fix 5).
                 registerCleanup(subscribeSession(sessionKey, (e) => {
                     sendEvent(e, e._seq);
                 }, replayHighSeq));
@@ -310,7 +311,6 @@ export function createSessionsRouter() {
                     res.write(`: keep-alive\n\n`);
                 }, 15_000);
                 registerCleanup(() => clearInterval(keepAlive));
-                req.on("close", cleanupNow);
             });
         });
     }

package/dist/api/sse-hub.js

@@ -1,14 +1,51 @@
 import { formatSseData } from "./sse.js";
+import { childLogger } from "../util/logger.js";
+export const MAX_PENDING_SSE_MESSAGES = 256;
+export const PENDING_SSE_MESSAGE_MAX_AGE_MS = 10 * 60 * 1_000;
 export const sseClients = new Map();
 export const pendingSseMessages = [];
+const log = childLogger("sse-hub");
 let connectionCounter = 0;
 export function nextSseConnectionId() {
     connectionCounter += 1;
     return `web-${connectionCounter}`;
 }
+function removeClient(connectionId, err) {
+    log.warn({ err, connectionId }, "SSE client write failed; removing client");
+    sseClients.delete(connectionId);
+}
+function writeClient(connectionId, client, payload) {
+    try {
+        client.res.write(payload);
+        return true;
+    }
+    catch (err) {
+        removeClient(connectionId, err);
+        return false;
+    }
+}
+function prunePendingSseMessages(now = Date.now()) {
+    while (pendingSseMessages.length > 0 &&
+        now - (pendingSseMessages[0]?.queuedAt ?? now) > PENDING_SSE_MESSAGE_MAX_AGE_MS) {
+        pendingSseMessages.shift();
+    }
+}
+function enqueuePendingSseMessage(content) {
+    const now = Date.now();
+    prunePendingSseMessages(now);
+    while (pendingSseMessages.length >= MAX_PENDING_SSE_MESSAGES) {
+        pendingSseMessages.shift();
+    }
+    pendingSseMessages.push({ content, queuedAt: now });
+}
+export function drainPendingSseMessages() {
+    prunePendingSseMessages();
+    return pendingSseMessages.splice(0, pendingSseMessages.length);
+}
 export function broadcastSsePayload(payload) {
-    for (const [, client] of sseClients) {
-        client.res.write(formatSseData(payload));
+    const frame = formatSseData(payload);
+    for (const [connectionId, client] of sseClients) {
+        writeClient(connectionId, client, frame);
     }
 }
 export function associateSseClient(connectionId, sessionKey) {
@@ -18,20 +55,22 @@ export function associateSseClient(connectionId, sessionKey) {
     }
 }
 export function broadcastSsePayloadToSession(sessionKey, payload) {
-    for (const [, client] of sseClients) {
+    const frame = formatSseData(payload);
+    for (const [connectionId, client] of sseClients) {
         if (client.sessionKey === sessionKey) {
-            client.res.write(formatSseData(payload));
+            writeClient(connectionId, client, frame);
         }
     }
 }
 /** Broadcast a proactive message to all connected SSE clients (for background task completions). */
 export function broadcastToSSE(text) {
     if (sseClients.size === 0) {
-        pendingSseMessages.push(text);
+        enqueuePendingSseMessage(text);
         return;
     }
-    for (const [, client] of sseClients) {
-        client.res.write(formatSseData({ type: "message", content: text }));
+    const frame = formatSseData({ type: "message", content: text });
+    for (const [connectionId, client] of sseClients) {
+        writeClient(connectionId, client, frame);
     }
 }
 //# sourceMappingURL=sse-hub.js.map

package/dist/api/sse-hub.test.js

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import { afterEach, test } from "node:test";
+import { broadcastSsePayload, broadcastSsePayloadToSession, broadcastToSSE, pendingSseMessages, sseClients, } from "./sse-hub.js";
+function fakeResponse(write) {
+    return { write };
+}
+afterEach(() => {
+    sseClients.clear();
+    pendingSseMessages.length = 0;
+    Date.now = originalDateNow;
+});
+const originalDateNow = Date.now;
+test("broadcastSsePayload continues fan-out when a client write throws and removes bad clients", () => {
+    const delivered = [];
+    sseClients.set("bad", {
+        sessionKey: null,
+        res: fakeResponse(() => {
+            throw new Error("socket closed");
+        }),
+    });
+    sseClients.set("good", {
+        sessionKey: null,
+        res: fakeResponse((chunk) => {
+            delivered.push(chunk);
+            return true;
+        }),
+    });
+    assert.doesNotThrow(() => broadcastSsePayload({ type: "cancelled" }));
+    assert.equal(delivered.length, 1);
+    assert.equal(sseClients.has("bad"), false);
+    assert.equal(sseClients.has("good"), true);
+});
+test("broadcastSsePayloadToSession removes a throwing matching client and still delivers to other matching clients", () => {
+    const delivered = [];
+    sseClients.set("bad", {
+        sessionKey: "agent:one",
+        res: fakeResponse(() => {
+            throw new Error("socket closed");
+        }),
+    });
+    sseClients.set("other-session", {
+        sessionKey: "agent:two",
+        res: fakeResponse(() => {
+            throw new Error("wrong session should not be written");
+        }),
+    });
+    sseClients.set("good", {
+        sessionKey: "agent:one",
+        res: fakeResponse((chunk) => {
+            delivered.push(chunk);
+            return true;
+        }),
+    });
+    assert.doesNotThrow(() => broadcastSsePayloadToSession("agent:one", { type: "agent_reloaded" }));
+    assert.equal(delivered.length, 1);
+    assert.equal(sseClients.has("bad"), false);
+    assert.equal(sseClients.has("good"), true);
+    assert.equal(sseClients.has("other-session"), true);
+});
+test("pending SSE messages are capped at 256 entries", () => {
+    for (let i = 0; i < 300; i++) {
+        broadcastToSSE(`message ${i}`);
+    }
+    assert.equal(pendingSseMessages.length, 256);
+    assert.equal(pendingSseMessages[0]?.content, "message 44");
+    assert.equal(pendingSseMessages[255]?.content, "message 299");
+});
+test("pending SSE messages older than 10 minutes are dropped when enqueueing", () => {
+    Date.now = () => 1_000;
+    broadcastToSSE("old");
+    Date.now = () => 1_000 + 10 * 60 * 1_000 + 1;
+    broadcastToSSE("fresh");
+    assert.deepEqual(pendingSseMessages.map((message) => message.content), ["fresh"]);
+});
+//# sourceMappingURL=sse-hub.test.js.map

package/dist/status.js

@@ -1,19 +1,27 @@
+import { childLogger } from "./util/logger.js";
 let currentStatus = "idle";
 let statusMessage = "";
 const listeners = new Set();
+const log = childLogger("status");
+function notifyListeners() {
+    for (const listener of listeners) {
+        try {
+            listener(currentStatus, statusMessage);
+        }
+        catch (err) {
+            log.warn({ err }, "status listener threw");
+        }
+    }
+}
 export function setBusy(reason, message) {
     currentStatus = reason;
     statusMessage = message;
-    for (const listener of listeners) {
-        listener(currentStatus, statusMessage);
-    }
+    notifyListeners();
 }
 export function setIdle() {
     currentStatus = "idle";
     statusMessage = "";
-    for (const listener of listeners) {
-        listener(currentStatus, statusMessage);
-    }
+    notifyListeners();
 }
 export function getStatus() {
     return { status: currentStatus, message: statusMessage };

package/dist/status.test.js

@@ -19,4 +19,22 @@ test("tracks dreaming status and notifies listeners", () => {
         { status: "idle", message: "" },
     ]);
 });
+test("continues notifying status listeners when one listener throws", () => {
+    const seen = [];
+    const unsubscribeThrowing = onStatusChange(() => {
+        throw new Error("write failed");
+    });
+    const unsubscribeHealthy = onStatusChange((status, message) => {
+        seen.push({ status, message });
+    });
+    try {
+        assert.doesNotThrow(() => setBusy("dreaming", "Still notifying"));
+        assert.deepEqual(seen, [{ status: "dreaming", message: "Still notifying" }]);
+    }
+    finally {
+        unsubscribeHealthy();
+        unsubscribeThrowing();
+        setIdle();
+    }
+});
 //# sourceMappingURL=status.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chapterhouse",
-  "version": "0.11.1",
+  "version": "0.11.3",
   "description": "Chapterhouse — a team-level AI assistant for engineering teams, built on the GitHub Copilot SDK. Web UI only.",
   "bin": {
     "chapterhouse": "dist/cli.js"