chapterhouse 0.3.24 → 0.3.26

package/dist/api/server-runtime.js

@@ -20,7 +20,7 @@ export function createHealthPayload(now = new Date()) {
     };
 }
 export function createPublicConfigPayload(config) {
-    const chatSseEnabled = config.chatSseEnabled ?? false;
+    const chatSseEnabled = config.chatSseEnabled ?? true;
     if (!config.entraAuthEnabled) {
         return {
             appName: "Chapterhouse",

package/dist/api/server.js

@@ -383,14 +383,34 @@ app.get("/api/workers/:taskId/events", (req, res) => {
         ? parseInt(rawLastId.trim(), 10)
         : undefined;
     const sendEvent = (event) => {
-        const payload = {
-            taskId: event.taskId,
-            seq: event.seq,
-            ts: event.ts,
-            kind: event.kind,
-            toolName: event.toolName,
-            summary: event.summary,
-        };
+        let payload;
+        if (event.kind === "output_delta") {
+            payload = {
+                type: "output_delta",
+                taskId: event.taskId,
+                seq: event.seq,
+                text: event.text ?? "",
+            };
+        }
+        else if (event.kind === "task_status") {
+            payload = {
+                type: "task_status",
+                taskId: event.taskId,
+                seq: event.seq,
+                status: event.status ?? "running",
+                summary: event.summary,
+            };
+        }
+        else {
+            payload = {
+                taskId: event.taskId,
+                seq: event.seq,
+                ts: event.ts,
+                kind: event.kind,
+                toolName: event.toolName,
+                summary: event.summary,
+            };
+        }
         res.write(`id: ${event.seq}\ndata: ${JSON.stringify(payload)}\n\n`);
     };
     let replayHighSeq = lastSeq;
@@ -427,24 +447,41 @@ app.get("/api/workers/:taskId/events", (req, res) => {
     const heartbeat = setInterval(() => {
         res.write(`: keep-alive\n\n`);
     }, 15_000);
-    const unsubscribeTaskLog = subscribeTaskLog(taskId, (event) => {
+    let cleaned = false;
+    let unsubscribeTaskLog;
+    let unsubscribeDestroyed;
+    let unsubscribeError;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        clearInterval(heartbeat);
+        unsubscribeTaskLog?.();
+        unsubscribeDestroyed?.();
+        unsubscribeError?.();
+    };
+    unsubscribeTaskLog = subscribeTaskLog(taskId, (event) => {
         sendEvent(event);
+        // Close SSE when a terminal task_status event arrives
+        if (event.kind === "task_status" && event.status && TERMINAL_TASK_STATUSES.has(event.status)) {
+            cleanup();
+            res.end();
+        }
     });
-    const unsubscribeDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
+    unsubscribeDestroyed = agentEventBus.subscribe("session:destroyed", (event) => {
         if (event.sessionId === taskId && isTerminal()) {
+            cleanup();
             res.end();
         }
     });
-    const unsubscribeError = agentEventBus.subscribe("session:error", (event) => {
+    unsubscribeError = agentEventBus.subscribe("session:error", (event) => {
         if (event.sessionId === taskId && isTerminal()) {
+            cleanup();
             res.end();
         }
     });
     req.on("close", () => {
-        clearInterval(heartbeat);
-        unsubscribeTaskLog();
-        unsubscribeDestroyed();
-        unsubscribeError();
+        cleanup();
     });
 });
 // ---------------------------------------------------------------------------
@@ -631,7 +668,7 @@ app.post("/api/sessions/:sessionKey/interrupt", (req, res) => {
     res.json({ status: "interrupting" });
 });
 // ---------------------------------------------------------------------------
-// Chat POST→SSE endpoints — gated by CHAPTERHOUSE_CHAT_SSE=1 (#130)
+// Chat POST→SSE endpoints — enabled by default, overridable via CHAPTERHOUSE_CHAT_SSE (#130)
 // ---------------------------------------------------------------------------
 const turnRequestSchema = z.object({
     prompt: z.string().trim().min(1, "Missing prompt"),

package/dist/api/server.test.js

@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
 import Database from "better-sqlite3";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 test("supports API_TOKEN env var and personal health route helpers", async () => {
     const runtime = await import("./server-runtime.js");
     assert.equal(typeof runtime.resolveApiToken, "function", "resolveApiToken should be exported");
@@ -29,25 +29,25 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: true,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.deepEqual(runtime.createPublicConfigPayload({
         entraAuthEnabled: false,
         standaloneMode: false,
         entraClientId: "client-id",
         entraTenantId: "tenant-id",
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     }), {
         appName: "Chapterhouse",
         entraAuthEnabled: false,
         standalone: false,
-        chatSseEnabled: false,
+        chatSseEnabled: true,
     });
     assert.doesNotThrow(() => runtime.assertAuthenticationConfigured({
         entraAuthEnabled: false,
@@ -62,6 +62,21 @@ test("supports API_TOKEN env var and personal health route helpers", async () =>
         apiToken: null,
     }));
 });
+test("createPublicConfigPayload defaults chat SSE on when not explicitly provided", async () => {
+    const runtime = await import("./server-runtime.js");
+    assert.equal(typeof runtime.createPublicConfigPayload, "function", "createPublicConfigPayload should be exported");
+    assert.deepEqual(runtime.createPublicConfigPayload({
+        entraAuthEnabled: false,
+        standaloneMode: true,
+        entraClientId: "client-id",
+        entraTenantId: "tenant-id",
+    }), {
+        appName: "Chapterhouse",
+        entraAuthEnabled: false,
+        standalone: true,
+        chatSseEnabled: true,
+    });
+});
 test("formats named SSE status events", async () => {
     const sse = await import("./sse.js");
     assert.equal(typeof sse.formatSseEvent, "function", "formatSseEvent should be exported");
@@ -109,42 +124,18 @@ function readProjectRegistryRows(testRoot) {
         db.close();
     }
 }
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
-}
 // Standalone mode triggers a full daemon init via the server→daemon circular import
 // (server.ts imports restartDaemon from daemon.ts, which has module-level main()).
 // The Copilot SDK's client.start() then blocks the event loop while authenticating,
-// so the HTTP server cannot respond until SDK init completes (~10-20 s depending on
-// session state).  Other modes complete in ~330 ms because the SDK yields quickly.
+// so the HTTP server cannot respond until SDK init completes (~10-30 s depending on
+// session state and runner load). Other modes usually complete much faster, but cold
+// CI starts can still exceed a 10 s budget.
 // Root cause tracked in decisions notes (backend fix: lazy-import or
-// guard env var in daemon.ts).  Interim fix: 30 s timeout for standalone, 10 s elsewhere.
+// guard env var in daemon.ts). Interim fix: use a more generous startup timeout for
+// integration tests while keeping the same /status readiness probe.
 // Additionally, strip COPILOT_* env vars from the child so it doesn't accidentally
 // piggy-back on the running agent session, which worsens the blocking behaviour.
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     const testRoot = join(repoRoot, ".test-work", `server-routes-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(testRoot, { recursive: true, force: true });
@@ -174,24 +165,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token", testRoot });
     }
     finally {
         await stopChild(child);
@@ -209,7 +184,7 @@ test("server routes expose bootstrap and public config without auth", async () =
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: false,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
     });
 });
@@ -224,14 +199,14 @@ test("server runs in standalone mode without auth", async () => {
             appName: "Chapterhouse",
             entraAuthEnabled: false,
             standalone: true,
-            chatSseEnabled: false,
+            chatSseEnabled: true,
         });
         const model = await fetch(`${baseUrl}/api/model`);
         assert.equal(model.status, 200);
         assert.deepEqual(await model.json(), { model: "claude-sonnet-4.6" });
     }, {
         API_TOKEN: "",
-    }, 30_000);
+    }, STANDALONE_API_SERVER_STARTUP_TIMEOUT_MS);
 });
 test("server bootstrap rejects non-loopback origins", async () => {
     await withStartedServer(async ({ baseUrl }) => {

package/dist/api/sse.integration.test.js

@@ -1,42 +1,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Server harness (copied from server.test.ts; distinct root path suffix to
 // avoid collision when both test files run in parallel in the same process).
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const sseTestRoot = join(repoRoot, ".test-work", `sse-integration-${process.pid}`);
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => {
-        server.listen(0, "127.0.0.1", () => resolve());
-    });
-    const address = server.address();
-    assert.ok(address && typeof address === "object", "server should expose a bound address");
-    await new Promise((resolve, reject) => {
-        server.close((err) => (err ? reject(err) : resolve()));
-    });
-    return address.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null) {
-        return;
-    }
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => {
-            if (child.exitCode === null) {
-                child.kill("SIGKILL");
-            }
-        }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     rmSync(sseTestRoot, { recursive: true, force: true });
     mkdirSync(sseTestRoot, { recursive: true });
@@ -65,24 +39,8 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (chunk) => logs.push(String(chunk)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null) {
-                throw new Error(`API server exited early:\n${logs.join("")}`);
-            }
-            try {
-                const response = await fetch(`${baseUrl}/status`);
-                if (response.ok) {
-                    await run({ baseUrl, authHeader: "Bearer route-token" });
-                    return;
-                }
-            }
-            catch {
-                // Server still starting.
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        throw new Error(`Timed out waiting for API server to start:\n${logs.join("")}`);
+        await waitForApiServerReady({ child, baseUrl, logs, timeoutMs });
+        await run({ baseUrl, authHeader: "Bearer route-token" });
     }
     finally {
         await stopChild(child);

package/dist/api/turn-sse.integration.test.js

@@ -2,8 +2,8 @@
  * Integration tests for the POST→SSE chat endpoints (#130).
  *
  * Tests:
- *  1. POST /api/sessions/:key/turn returns 404 when flag is off
- *  2. GET /api/sessions/:key/stream returns 404 when flag is off
+ *  1. POST /api/sessions/:key/turn returns 404 when flag is explicitly off
+ *  2. GET /api/sessions/:key/stream returns 404 when flag is explicitly off
  *  3. POST /api/sessions/:key/turn returns { turnId } when flag is on
  *  4. GET /api/sessions/:key/stream delivers turn events (SSE)
  *  5. SSE reconnect with Last-Event-ID replays missed events
@@ -11,8 +11,8 @@
  *  7. Legacy POST /api/message path unaffected when flag is off
  *
  * The tests that require the feature flag spawn a separate server process with
- * CHAPTERHOUSE_CHAT_SSE=1.  Tests that verify flag-off behavior use a server
- * without the flag.
+ * CHAPTERHOUSE_CHAT_SSE defaults on. Tests that verify flag-off behavior use a
+ * server with CHAPTERHOUSE_CHAT_SSE=0.
  *
  * Because the Copilot SDK is not available in test env (no valid token), tests
  * that would trigger a real turn instead verify the API shape and event
@@ -23,34 +23,16 @@
 import assert from "node:assert/strict";
 import { spawn } from "node:child_process";
 import { mkdirSync, rmSync } from "node:fs";
-import { createServer } from "node:http";
 import { join } from "node:path";
 import test from "node:test";
+import { DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS, getFreePort, stopChild, waitForApiServerReady, } from "../test/api-server.js";
 // ---------------------------------------------------------------------------
 // Helpers — copied/adapted from sse.integration.test.ts
 // ---------------------------------------------------------------------------
 const repoRoot = process.cwd();
 const testWorkRoot = join(repoRoot, ".test-work", `turn-sse-${process.pid}`);
 let _instanceCounter = 0;
-async function getFreePort() {
-    const server = createServer();
-    await new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve()));
-    const addr = server.address();
-    assert.ok(addr && typeof addr === "object");
-    await new Promise((resolve, reject) => server.close((e) => (e ? reject(e) : resolve())));
-    return addr.port;
-}
-async function stopChild(child) {
-    if (child.exitCode !== null)
-        return;
-    child.kill("SIGTERM");
-    await new Promise((resolve) => {
-        child.once("exit", () => resolve());
-        setTimeout(() => { if (child.exitCode === null)
-            child.kill("SIGKILL"); }, 2_000);
-    });
-}
-async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
+async function withStartedServer(run, extraEnv = {}, timeoutMs = DEFAULT_API_SERVER_STARTUP_TIMEOUT_MS) {
     mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
     const instanceRoot = `${testWorkRoot}-${Date.now()}-${++_instanceCounter}`;
     rmSync(instanceRoot, { recursive: true, force: true });
@@ -78,24 +60,15 @@ async function withStartedServer(run, extraEnv = {}, timeoutMs = 10_000) {
     child.stderr?.on("data", (c) => logs.push(String(c)));
     const baseUrl = `http://127.0.0.1:${port}`;
     try {
-        const deadline = Date.now() + timeoutMs;
-        while (Date.now() < deadline) {
-            if (child.exitCode !== null)
-                throw new Error(`Server exited early:\n${logs.join("")}`);
-            let serverReady = false;
-            try {
-                const r = await fetch(`${baseUrl}/status`);
-                serverReady = r.ok;
-            }
-            catch { /* not ready yet */ }
-            if (serverReady) {
-                // Run outside the fetch try/catch so assertion errors propagate correctly.
-                await run({ baseUrl, authHeader: "Bearer test-token" });
-                return;
-            }
-            await new Promise((r) => setTimeout(r, 100));
-        }
-        throw new Error(`Server did not start in ${timeoutMs}ms:\n${logs.join("")}`);
+        await waitForApiServerReady({
+            child,
+            baseUrl,
+            logs,
+            timeoutMs,
+            timeoutMessage: `Server did not start in ${timeoutMs}ms`,
+            exitMessage: "Server exited early",
+        });
+        await run({ baseUrl, authHeader: "Bearer test-token" });
     }
     finally {
         await stopChild(child);
@@ -162,18 +135,18 @@ test("turn-sse: POST /api/sessions/:key/turn returns 404 when flag is off", asyn
             headers: { Authorization: authHeader, "Content-Type": "application/json" },
             body: JSON.stringify({ prompt: "hello" }),
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
         const body = await res.json();
         assert.ok(typeof body.error === "string" && body.error.includes("Chat SSE"), `Expected error about Chat SSE, got: ${body.error}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: GET /api/sessions/:key/stream returns 404 when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
         const res = await fetch(`${baseUrl}/api/sessions/default/stream`, {
             headers: { Authorization: authHeader },
         });
-        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE is not set");
-    });
+        assert.equal(res.status, 404, "Should return 404 when CHAPTERHOUSE_CHAT_SSE=0");
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 test("turn-sse: legacy POST /api/message is unaffected when flag is off", async () => {
     await withStartedServer(async ({ baseUrl, authHeader }) => {
@@ -186,7 +159,7 @@ test("turn-sse: legacy POST /api/message is unaffected when flag is off", async
         });
         // 400 = route exists and validated the request (connectionId not found in sseClients)
         assert.ok(res.status === 400 || res.status === 401 || res.status === 422, `Expected 4xx from /api/message, got ${res.status}`);
-    });
+    }, { CHAPTERHOUSE_CHAT_SSE: "0" });
 });
 // ---------------------------------------------------------------------------
 // Tests: feature flag ON