@repo-prism/dispatch-hub 1.1.16 → 1.8.0

package/dist/server.js

@@ -3,15 +3,22 @@ import { access } from "node:fs/promises";
 import { createReadStream } from "node:fs";
 import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createClaudeWorkerPort, createCursorWorkerPort, createDispatchRuntime, readRunLog, } from "@repo-prism/dispatch";
-import { originAllowed, tokenFromRequest, tokensMatch } from "./auth.js";
+import { createClaudeWorkerPort, createCursorWorkerPort, createDispatchRuntime, DispatchConfigSchema, discoverHostConnectors, vendorCoverage, drainWorkspace, loadConfig, listWorkerModels, requestedWorkerModel, resolveWorkerBackend, getJob, upsertJob, readRunLog, saveConfig, } from "@repo-prism/dispatch";
+import { parseHostRequest } from "@repo-prism/host-session/protocol";
+import { originAllowed, tokenFromRequest, tokensMatch, hubCookieHeader, } from "./auth.js";
 import { createIdleTimer, IDLE_MS } from "./idle.js";
-import { newHubToken, packageVersion, writeHubRecord } from "./hub-record.js";
+import { createIntelligencePlane, } from "./intelligence.js";
+import { newHubToken, packageVersion, readHubRecord, writeHubRecord, } from "./hub-record.js";
 import { formatJobFinishedNotice } from "./notice.js";
+import { listJobNotes, readJobNote } from "./notes.js";
 import { createOsNotifier } from "./notify.js";
+import { readHostTelemetry } from "./host-telemetry.js";
 import { dashboardUrl, hubPort } from "./paths.js";
-import { dropMissingWorkspaces, registerWorkspace } from "./registry.js";
+import { HUB_ERROR, publicCaughtError } from "./api-errors.js";
+import { pickLocalFolder } from "./pick-folder.js";
+import { dropMissingWorkspaces, registerWorkspace, unregisterWorkspace, workspaceLabel, } from "./registry.js";
 import { collectJobs, isInFlight, pathExists, watchWorkspaces, } from "./watch.js";
+import { toSnapshot } from "./snapshot.js";
 const MIME = {
     ".html": "text/html; charset=utf-8",
     ".js": "text/javascript; charset=utf-8",
@@ -22,25 +29,74 @@ const MIME = {
 function defaultAssetsDir() {
     return join(dirname(fileURLToPath(import.meta.url)), "dashboard");
 }
-async function defaultControl(workspacePath, jobId, action) {
+async function defaultStartJob(workspacePath, args) {
     const runtime = createDispatchRuntime({
         workspaceRoot: workspacePath,
         worker: createCursorWorkerPort(),
         claudeWorker: createClaudeWorkerPort(),
+        getClientName: () => String(args.hostClient ?? "console"),
+    });
+    return runtime.handle("start_job", {
+        ...args,
+        hostClient: args.hostClient ?? "console",
+    });
+}
+async function defaultControl(workspacePath, jobId, action, extra) {
+    const runtime = createDispatchRuntime({
+        workspaceRoot: workspacePath,
+        worker: createCursorWorkerPort(),
+        claudeWorker: createClaudeWorkerPort(),
+        getClientName: () => "console",
+        ...(action === "reverify" ? { deferVerify: true } : {}),
+    });
+    return runtime.handle("job_control", {
+        jobId,
+        action,
+        ...(extra?.path ? { path: extra.path } : {}),
+        ...(extra?.context ? { context: extra.context } : {}),
     });
-    return runtime.handle("job_control", { jobId, action });
+}
+/**
+ * Advance one workspace's job queue (ADR-0047).
+ *
+ * The hub is the only always-on process on the machine, which makes it the
+ * right owner of the drain: a job queued by an MCP server that has since
+ * exited still starts, and a job parked behind the cap starts as soon as a
+ * slot frees.
+ */
+async function defaultDrain(workspacePath) {
+    const cursor = createCursorWorkerPort();
+    const claude = createClaudeWorkerPort();
+    const runtime = createDispatchRuntime({
+        workspaceRoot: workspacePath,
+        worker: cursor,
+        claudeWorker: claude,
+    });
+    await drainWorkspace(runtime.drainDeps());
 }
 export async function startHub(options = {}) {
     const env = options.env ?? process.env;
     const notify = options.notify ?? createOsNotifier();
     const assetsDir = options.assetsDir ?? defaultAssetsDir();
     const control = options.control ?? defaultControl;
+    const startJob = options.startJob ?? defaultStartJob;
     const version = options.version ?? packageVersion();
-    const token = newHubToken();
+    const intelligence = options.intelligence ?? createIntelligencePlane();
+    const pickFolder = options.pickFolder ?? pickLocalFolder;
+    const listModels = options.listWorkerModels ??
+        ((input) => listWorkerModels({ backend: input.backend }));
+    const previous = await readHubRecord(env);
+    const token = typeof previous?.token === "string" && previous.token.length >= 16
+        ? previous.token
+        : newHubToken();
     const wantedPort = hubPort(env);
     let workspaces = await dropMissingWorkspaces(pathExists, env);
     const sse = new Set();
     let jobs = [];
+    // Mirrored from the watcher so every payload can state when it was read and
+    // which workspaces failed, rather than presenting a partial list as whole.
+    let asOf = new Date().toISOString();
+    let workspaceErrors = [];
     let server;
     let closed = false;
     let liveRecord = {
@@ -51,8 +107,11 @@ export async function startHub(options = {}) {
         startedAt: new Date().toISOString(),
     };
     const broadcast = (event) => {
-        if (event.type === "snapshot")
+        if (event.type === "snapshot") {
             jobs = [...event.jobs];
+            asOf = event.asOf;
+            workspaceErrors = [...event.errors];
+        }
         if (event.type === "job.updated") {
             jobs = [
                 ...jobs.filter((row) => !(row.id === event.job.id &&
@@ -60,6 +119,10 @@ export async function startHub(options = {}) {
                 event.job,
             ];
         }
+        if (event.type === "job.removed") {
+            jobs = jobs.filter((row) => !(row.id === event.job.id &&
+                row.workspacePath === event.job.workspacePath));
+        }
         const payload = `data: ${JSON.stringify(event)}\n\n`;
         for (const client of sse) {
             try {
@@ -77,8 +140,12 @@ export async function startHub(options = {}) {
         }
         idle.touch();
     };
+    // The hub tick is the queue's safety net (ADR-0047). `start_job` kicks its
+    // own drain, but that kick dies with the MCP process; this catches anything
+    // left `queued`, and re-checks jobs parked behind the concurrency cap.
     const watcher = watchWorkspaces(() => workspaces, onEvent, {
         pollMs: options.pollMs,
+        drain: options.drain ?? defaultDrain,
     });
     const idle = createIdleTimer({
         idleMs: options.idleMs ?? IDLE_MS,
@@ -93,6 +160,7 @@ export async function startHub(options = {}) {
         closed = true;
         idle.stop();
         watcher.close();
+        intelligence.close();
         for (const client of sse) {
             try {
                 client.res.end();
@@ -107,7 +175,18 @@ export async function startHub(options = {}) {
                 resolve();
                 return;
             }
-            server.close(() => resolve());
+            const timer = setTimeout(resolve, 1_000);
+            timer.unref();
+            server.close(() => {
+                clearTimeout(timer);
+                resolve();
+            });
+            try {
+                server.closeAllConnections();
+            }
+            catch {
+                /* bun / older node */
+            }
         });
     };
     server = createServer((req, res) => {
@@ -133,13 +212,21 @@ export async function startHub(options = {}) {
     }
     liveRecord = { ...liveRecord, port: listen.port };
     await writeHubRecord(liveRecord, env);
-    jobs = await collectJobs(workspaces);
-    broadcast({ type: "snapshot", jobs });
+    void listModels({ backend: "cursor" }).catch(() => {
+        /* spawn still lists if this misses */
+    });
+    const initial = await collectJobs(workspaces);
+    broadcast({
+        type: "snapshot",
+        jobs: initial.jobs,
+        asOf: new Date().toISOString(),
+        errors: initial.errors,
+    });
     async function handleRequest(req, res) {
         const host = req.headers.host ?? `127.0.0.1:${liveRecord.port}`;
         const url = new URL(req.url ?? "/", `http://${host}`);
         if (!originAllowed(req.headers.origin)) {
-            json(res, 403, { error: "origin not allowed" });
+            json(res, 403, { error: HUB_ERROR.origin });
             return;
         }
         if (url.pathname === "/api/healthz") {
@@ -149,16 +236,157 @@ export async function startHub(options = {}) {
                 pid: process.pid,
                 version,
                 workspaces: workspaces.length,
+                // Whether the Intelligence plane has actually loaded Core, and on
+                // what. A reader can tell an idle Console from a busy one.
+                intelligence: {
+                    loaded: intelligence.loaded(),
+                    workspace: intelligence.openWorkspace() ?? null,
+                },
             });
             return;
         }
         const isApi = url.pathname.startsWith("/api/");
         if (isApi && !tokensMatch(liveRecord.token, tokenFromRequest(req, url))) {
-            json(res, 401, { error: "unauthorized" });
+            json(res, 401, { error: HUB_ERROR.unauthorized });
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/telemetry/host") {
+            json(res, 200, await readHostTelemetry(workspaces[0]?.path ?? process.cwd()));
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/worker-models") {
+            const requested = url.searchParams.get("backend")?.trim();
+            const workspace = url.searchParams.get("workspace")?.trim() || workspaces[0]?.path;
+            let backend;
+            if (requested === "cursor" || requested === "claude") {
+                backend = requested;
+            }
+            else {
+                const config = workspace
+                    ? await loadConfig(workspace).catch(() => undefined)
+                    : undefined;
+                backend = resolveWorkerBackend({ config, env });
+            }
+            json(res, 200, {
+                backend,
+                models: await listModels({ backend }),
+            });
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/api/jobs") {
+            const body = await readBody(req);
+            const workspace = String(body.workspace ?? "").trim() || workspaces[0]?.path || "";
+            const title = String(body.title ?? "").trim();
+            if (!workspace || !title) {
+                json(res, 400, { error: HUB_ERROR.titleRequired });
+                return;
+            }
+            try {
+                const workerModel = requestedWorkerModel(body.workerModel ?? body.model);
+                const origin = body.origin === "retry" ||
+                    body.origin === "reverify" ||
+                    body.origin === "finding" ||
+                    body.origin === "instruct"
+                    ? body.origin
+                    : undefined;
+                const parentJobId = String(body.parentJobId ?? "").trim();
+                const result = await startJob(workspace, {
+                    title,
+                    prd: String(body.prd ?? ""),
+                    playbook: String(body.playbook ?? "console"),
+                    ...(body.placement === "worktree" || body.placement === "checkout"
+                        ? { placement: body.placement }
+                        : {}),
+                    ...(body.workerBackend === "cursor" || body.workerBackend === "claude"
+                        ? { workerBackend: body.workerBackend }
+                        : {}),
+                    ...(workerModel ? { workerModel } : {}),
+                    ...(parentJobId ? { parentJobId } : {}),
+                    ...(origin ? { origin } : {}),
+                    hostClient: "console",
+                });
+                await watcher.refresh({ drain: true });
+                json(res, 200, result ?? { ok: true });
+            }
+            catch (cause) {
+                json(res, 500, { error: publicCaughtError(cause) });
+            }
+            return;
+        }
+        const jobPatch = /^\/api\/jobs\/([^/]+)$/.exec(url.pathname);
+        if (req.method === "PATCH" && jobPatch) {
+            const jobId = decodeURIComponent(jobPatch[1] ?? "");
+            const body = await readBody(req);
+            const workspace = String(body.workspace ?? "").trim() ||
+                jobs.find((job) => job.id === jobId)?.workspacePath ||
+                "";
+            if (!workspace || !jobId) {
+                json(res, 400, { error: HUB_ERROR.workspaceJob });
+                return;
+            }
+            if (!("prd" in body)) {
+                json(res, 400, { error: HUB_ERROR.prdRequired });
+                return;
+            }
+            try {
+                const current = await getJob(workspace, jobId);
+                if (!current) {
+                    json(res, 404, { error: HUB_ERROR.jobMissing });
+                    return;
+                }
+                const next = await upsertJob(workspace, {
+                    ...current,
+                    prd: String(body.prd ?? ""),
+                });
+                await watcher.refresh({ drain: false });
+                json(res, 200, {
+                    job: toSnapshot(next, workspace),
+                    message: "Saved the brief.",
+                });
+            }
+            catch (cause) {
+                json(res, 500, { error: publicCaughtError(cause) });
+            }
             return;
         }
         if (req.method === "GET" && url.pathname === "/api/jobs") {
-            json(res, 200, { jobs });
+            json(res, 200, {
+                jobs: [...watcher.jobs()],
+                asOf: watcher.asOf(),
+                errors: [...watcher.errors()],
+            });
+            return;
+        }
+        // The Repos plane needs to tell "no repositories registered" apart from
+        // "registered, but no jobs" — two very different things the old board
+        // rendered as one empty sentence (ADR-0048).
+        if (req.method === "GET" && url.pathname === "/api/repos") {
+            json(res, 200, {
+                repos: workspaces.map((entry) => ({
+                    path: entry.path,
+                    label: entry.label,
+                    lastSeenAt: entry.lastSeenAt,
+                    jobCount: jobs.filter((job) => job.workspacePath === entry.path)
+                        .length,
+                    error: workspaceErrors.find((row) => row.workspacePath === entry.path)
+                        ?.detail,
+                })),
+                asOf,
+            });
+            return;
+        }
+        // What the user's agent window already has connected (ADR-0049). Served
+        // from here rather than read directly by the IDE, so the extension keeps
+        // its one dependency on Dispatch — HTTP — instead of importing it.
+        if (req.method === "GET" && url.pathname === "/api/connectors") {
+            const workspace = url.searchParams.get("workspace")?.trim() || workspaces[0]?.path;
+            const discovery = await discoverHostConnectors(workspace ? { workspaceRoot: workspace } : {});
+            json(res, 200, {
+                connectors: discovery.connectors,
+                unreadable: discovery.unreadable,
+                vendors: vendorCoverage(discovery.connectors),
+                asOf: new Date().toISOString(),
+            });
             return;
         }
         // Per-job console for the board's expander (M-066 P-P6).
@@ -169,15 +397,55 @@ export async function startHub(options = {}) {
                 jobs.find((job) => job.id === jobId)?.workspacePath ??
                 "";
             if (!workspace) {
-                json(res, 400, { error: "workspace required" });
+                json(res, 400, { error: HUB_ERROR.workspaceRequired });
                 return;
             }
+            const since = url.searchParams.get("since")?.trim();
             const page = await readRunLog(workspace, jobId, {
                 limit: Number(url.searchParams.get("limit") ?? "200") || 200,
+                ...(since ? { since } : {}),
             });
             json(res, 200, page);
             return;
         }
+        const notesMatch = /^\/api\/jobs\/([^/]+)\/notes$/.exec(url.pathname);
+        if (req.method === "GET" && notesMatch) {
+            const jobId = decodeURIComponent(notesMatch[1] ?? "");
+            const job = jobs.find((row) => row.id === jobId);
+            const workspace = url.searchParams.get("workspace") ?? job?.workspacePath ?? "";
+            if (!workspace) {
+                json(res, 400, { error: HUB_ERROR.workspaceRequired });
+                return;
+            }
+            const rel = url.searchParams.get("path")?.trim();
+            try {
+                if (rel) {
+                    const file = await readJobNote({
+                        workspace,
+                        rel,
+                        ...(job?.worktreePath ? { worktreePath: job.worktreePath } : {}),
+                    });
+                    if (!file) {
+                        json(res, 404, { error: HUB_ERROR.noteMissing });
+                        return;
+                    }
+                    json(res, 200, file);
+                    return;
+                }
+                const listed = await listJobNotes({
+                    workspace,
+                    jobId,
+                    ...(job?.worktreePath ? { worktreePath: job.worktreePath } : {}),
+                    ...(job?.resultSummary ? { summary: job.resultSummary } : {}),
+                    ...(job?.notes ? { stored: job.notes } : {}),
+                });
+                json(res, 200, { notes: listed });
+            }
+            catch {
+                json(res, 500, { error: HUB_ERROR.noteRead });
+            }
+            return;
+        }
         if (req.method === "GET" && url.pathname === "/api/events") {
             res.writeHead(200, {
                 "Content-Type": "text/event-stream",
@@ -187,7 +455,12 @@ export async function startHub(options = {}) {
             const client = { res };
             sse.add(client);
             idle.touch();
-            res.write(`data: ${JSON.stringify({ type: "snapshot", jobs })}\n\n`);
+            res.write(`data: ${JSON.stringify({
+                type: "snapshot",
+                jobs: [...watcher.jobs()],
+                asOf: watcher.asOf(),
+                errors: [...watcher.errors()],
+            })}\n\n`);
             req.on("close", () => {
                 sse.delete(client);
             });
@@ -197,7 +470,7 @@ export async function startHub(options = {}) {
             const body = await readBody(req);
             const path = String(body.path ?? "").trim();
             if (!path) {
-                json(res, 400, { error: "path required" });
+                json(res, 400, { error: HUB_ERROR.pathRequired });
                 return;
             }
             workspaces = await registerWorkspace(path, env);
@@ -205,6 +478,74 @@ export async function startHub(options = {}) {
             json(res, 200, { workspaces });
             return;
         }
+        if (req.method === "POST" && url.pathname === "/api/workspaces/remove") {
+            const body = await readBody(req);
+            const path = String(body.path ?? "").trim();
+            if (!path) {
+                json(res, 400, { error: HUB_ERROR.pathRequired });
+                return;
+            }
+            const before = workspaces.length;
+            workspaces = await unregisterWorkspace(path, env);
+            if (workspaces.length === before) {
+                json(res, 404, { error: "That repository is not registered." });
+                return;
+            }
+            void watcher.refresh();
+            json(res, 200, { workspaces });
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/api/workspaces/pick") {
+            const picked = await pickFolder();
+            if (!picked) {
+                json(res, 200, { cancelled: true });
+                return;
+            }
+            workspaces = await registerWorkspace(picked, env);
+            void watcher.refresh();
+            json(res, 200, {
+                path: picked,
+                label: workspaceLabel(picked),
+                workspaces,
+            });
+            return;
+        }
+        // The Intelligence plane (ADR-0048). Same `HostRequest`/`HostResponse`
+        // contract the IDE webview already speaks, so `@repo-prism/app-shell`
+        // mounts against it unchanged — but behind this Console's token and origin
+        // allowlist, rather than the retired bridge's `Access-Control-Allow-Origin: *`.
+        if (req.method === "POST" && url.pathname === "/api/host") {
+            const body = await readBody(req);
+            const id = typeof body.id === "string" ? body.id : "?";
+            // Validated with the same guard the webview host uses, so an unknown
+            // method is a 400 here rather than an unhandled cast three layers down.
+            const parsed = parseHostRequest(body);
+            if (!parsed.ok) {
+                json(res, 400, { id, ok: false, error: parsed.reason });
+                return;
+            }
+            const workspace = (typeof body.workspace === "string" ? body.workspace.trim() : "") ||
+                url.searchParams.get("workspace") ||
+                workspaces[0]?.path ||
+                "";
+            if (!workspace) {
+                json(res, 200, {
+                    id,
+                    ok: false,
+                    error: "No repository registered with Prism yet. Open a repo in your editor, or run a Prism command in it.",
+                });
+                return;
+            }
+            idle.touch();
+            try {
+                const answer = await intelligence.handle(workspace, parsed.value);
+                json(res, 200, answer);
+            }
+            catch (cause) {
+                json(res, 200, { id, ok: false, error: publicCaughtError(cause) });
+            }
+            return;
+        }
         const controlMatch = /^\/api\/jobs\/([^/]+)\/control$/.exec(url.pathname);
         if (req.method === "POST" && controlMatch) {
             const jobId = decodeURIComponent(controlMatch[1] ?? "");
@@ -213,36 +554,87 @@ export async function startHub(options = {}) {
             const workspace = String(body.workspace ?? "").trim() ||
                 jobs.find((job) => job.id === jobId)?.workspacePath;
             if (!workspace || !action) {
-                json(res, 400, { error: "workspace and action required" });
+                json(res, 400, { error: HUB_ERROR.actionRequired });
                 return;
             }
             try {
-                const result = await control(workspace, jobId, action);
-                void watcher.refresh();
+                const extra = {
+                    ...(typeof body.path === "string" ? { path: body.path } : {}),
+                    ...(typeof body.context === "string"
+                        ? { context: body.context }
+                        : {}),
+                };
+                const result = await control(workspace, jobId, action, extra);
+                await watcher.refresh({ drain: false });
                 json(res, 200, result ?? { ok: true });
             }
             catch (cause) {
-                const message = cause instanceof Error ? cause.message : String(cause);
-                json(res, 500, { error: message });
+                json(res, 500, { error: publicCaughtError(cause) });
+            }
+            return;
+        }
+        if (req.method === "GET" && url.pathname === "/api/settings") {
+            const workspace = url.searchParams.get("workspace")?.trim() || workspaces[0]?.path;
+            if (!workspace) {
+                json(res, 400, { error: HUB_ERROR.workspaceRequired });
+                return;
             }
+            const config = await loadConfig(workspace);
+            const entry = workspaces.find((row) => row.path === workspace);
+            json(res, 200, {
+                workspace,
+                label: entry?.label ?? workspace,
+                config,
+            });
+            return;
+        }
+        if (req.method === "POST" && url.pathname === "/api/settings") {
+            const body = await readBody(req);
+            const workspace = String(body.workspace ?? "").trim() || workspaces[0]?.path;
+            if (!workspace) {
+                json(res, 400, { error: HUB_ERROR.workspaceRequired });
+                return;
+            }
+            const parsed = DispatchConfigSchema.partial().safeParse(body);
+            if (!parsed.success) {
+                json(res, 400, { error: publicCaughtError(parsed.error) });
+                return;
+            }
+            const patch = {};
+            for (const [key, value] of Object.entries(parsed.data)) {
+                if (value !== undefined)
+                    patch[key] = value;
+            }
+            const config = await saveConfig(workspace, patch);
+            json(res, 200, { workspace, config });
             return;
         }
         if (req.method === "GET" &&
             (url.pathname === "/" || url.pathname === "/index.html")) {
-            await serveFile(res, join(assetsDir, "index.html"), "text/html; charset=utf-8");
+            const headers = {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-store",
+            };
+            if (tokensMatch(liveRecord.token, tokenFromRequest(req, url))) {
+                headers["Set-Cookie"] = hubCookieHeader(liveRecord.token);
+            }
+            await serveFile(res, join(assetsDir, "index.html"), headers);
             return;
         }
         if (req.method === "GET" && url.pathname.startsWith("/assets/")) {
             const relative = url.pathname.slice("/assets/".length);
             if (relative.includes("..")) {
-                json(res, 400, { error: "bad path" });
+                json(res, 400, { error: HUB_ERROR.badPath });
                 return;
             }
             const file = join(assetsDir, relative);
-            await serveFile(res, file, MIME[extname(file)] ?? "application/octet-stream");
+            await serveFile(res, file, {
+                "Content-Type": MIME[extname(file)] ?? "application/octet-stream",
+                "Cache-Control": "no-store",
+            });
             return;
         }
-        json(res, 404, { error: "not found" });
+        json(res, 404, { error: HUB_ERROR.notFound });
     }
     return {
         record: liveRecord,
@@ -268,15 +660,15 @@ async function readBody(req) {
         return {};
     }
 }
-async function serveFile(res, path, mime) {
+async function serveFile(res, path, headers) {
     try {
         await access(path);
     }
     catch {
-        json(res, 404, { error: "not found" });
+        json(res, 404, { error: HUB_ERROR.notFound });
         return;
     }
-    res.writeHead(200, { "Content-Type": mime });
+    res.writeHead(200, headers);
     createReadStream(path).pipe(res);
 }
 //# sourceMappingURL=server.js.map