harness-dispatch 0.4.0 → 0.6.0

package/dist/http/server.js

@@ -6,7 +6,12 @@ import { buildMcpServer, buildMcpServerInstance, } from "../mcp/server.js";
 import { buildStatus, buildUsage } from "../status.js";
 import { evaluateRoutePolicy } from "../route-policy.js";
 import { isIsolatedWorkspacePolicy } from "../workspaces.js";
-import { resolveWorkingDir, workingDirWarning } from "../working-dir.js";
+import { getAsyncJob, startAsyncJobTracked } from "../jobs.js";
+import { BadRequestError, completionEnvelope, parseChatRequest, PayloadTooLargeError, readJson, } from "./parse.js";
+// Re-exported: BadRequestError is part of this module's public surface
+// (tests and the CLI import it from here) and moving its definition should
+// not move where callers get it from.
+export { BadRequestError };
 function sendJson(res, statusCode, body) {
     const text = JSON.stringify(body, null, 2);
     res.writeHead(statusCode, {
@@ -27,148 +32,236 @@ function isLoopbackHost(host) {
     // included — it means "bind all interfaces," the opposite of loopback.
     return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
-// Local-only server, but still worth bounding: an unbounded body read lets
-// any authorized (or, if --host is opened beyond loopback, network-adjacent)
-// caller exhaust process memory with one oversized POST.
-const MAX_REQUEST_BODY_BYTES = 10 * 1024 * 1024;
-class PayloadTooLargeError extends Error {
+/**
+ * Run fanout arms to completion INDEPENDENTLY of one another.
+ *
+ * Promise.all rejected the whole batch when one arm threw (workspace lock
+ * timeout, worktree setup failure), discarding every other arm's completed —
+ * and possibly billed — work behind a single 500. Each arm now settles on its
+ * own; a thrown arm becomes a failed row naming its route. One row shape for
+ * the streaming and non-streaming branches on purpose: they used to differ
+ * (streaming omitted success/error), the one-sibling-guarded pattern again.
+ */
+async function runFanoutArms(router, routes, parsed) {
+    const settled = await Promise.allSettled(routes.map((route) => router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
+        ...(parsed.hints.safetyProfile !== undefined
+            ? { safetyProfile: parsed.hints.safetyProfile }
+            : {}),
+        ...(parsed.hints.workspacePolicy !== undefined
+            ? { workspacePolicy: parsed.hints.workspacePolicy }
+            : {}),
+        ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
+    })));
+    return settled.map((s, i) => {
+        if (s.status === "fulfilled") {
+            const r = s.value.result;
+            return {
+                route: r.service,
+                success: r.success,
+                output: r.output,
+                ...(r.error !== undefined ? { error: r.error } : {}),
+                ...(r.workspace !== undefined ? { workspace: r.workspace } : {}),
+            };
+        }
+        return {
+            route: routes[i],
+            success: false,
+            output: "",
+            error: s.reason instanceof Error ? s.reason.message : String(s.reason),
+        };
+    });
 }
-async function readJson(req, maxBytes = MAX_REQUEST_BODY_BYTES) {
-    const chunks = [];
-    let total = 0;
-    for await (const chunk of req) {
-        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-        total += buf.length;
-        if (total > maxBytes) {
-            // Don't destroy() the socket here — that races with the 413 response
-            // write and the client sees a connection reset instead of a clean
-            // status code. Just stop buffering (the memory-exhaustion risk this
-            // guards against) and let the normal response path write the 413.
-            throw new PayloadTooLargeError(`request body exceeds ${maxBytes} bytes`);
+/**
+ * POST /v1/chat/completions — extracted from the request callback, where
+ * this logic sat eleven brace-levels deep (the smell checker's worst
+ * finding for the whole repo). Behaviour is unchanged; only the nesting
+ * moved.
+ */
+async function handleChatCompletions(holder, parsed, res, sse) {
+    const state = holder.state;
+    if (parsed.mode === "fanout") {
+        const fanoutSafetyProfile = parsed.hints.safetyProfile ?? "read_only";
+        if (fanoutSafetyProfile !== "read_only" &&
+            (parsed.hints.workspacePolicy === undefined ||
+                !isIsolatedWorkspacePolicy(parsed.hints.workspacePolicy))) {
+            sendJson(res, 400, {
+                error: {
+                    message: "write-capable fanout requires workspacePolicy=copy or workspacePolicy=git_worktree; use read_only fanout or run single-route workspace_edit",
+                    code: "workspace_isolation_required",
+                },
+            });
+            return;
         }
-        chunks.push(buf);
+        parsed.hints.safetyProfile = fanoutSafetyProfile;
     }
-    const text = Buffer.concat(chunks).toString("utf-8");
-    return text.trim() ? JSON.parse(text) : {};
-}
-function contentToText(content) {
-    if (typeof content === "string")
-        return content;
-    if (Array.isArray(content)) {
-        return content
-            .map((part) => {
-            if (typeof part === "string")
-                return part;
-            if (part && typeof part === "object" && "text" in part) {
-                const text = part.text;
-                return typeof text === "string" ? text : "";
+    const eligibleRoutes = (requestedRoutes) => {
+        const routes = [];
+        const skippedRoutes = [];
+        for (const route of requestedRoutes) {
+            const svc = state.config.services[route];
+            if (!svc) {
+                // The MCP tool rejects unknown fanout targets by name; this
+                // surface silently skipped them, returning 200 with fewer arms
+                // and an empty skippedRoutes. Same input, two answers.
+                throw new BadRequestError(`Unknown fanout target: ${route}. Valid route ids: ` +
+                    `${Object.keys(state.config.services).join(", ")}.`);
             }
-            return "";
-        })
-            .filter(Boolean)
-            .join("\n");
-    }
-    return "";
-}
-function messagesToPrompt(messages) {
-    if (!Array.isArray(messages))
-        return "";
-    return messages
-        .map((message) => {
-        const role = typeof message.role === "string" ? message.role : "user";
-        const text = contentToText(message.content);
-        return text ? `${role}: ${text}` : "";
-    })
-        .filter(Boolean)
-        .join("\n\n");
-}
-function parseHints(body) {
-    const hints = {};
-    if (typeof body.model === "string" && body.model !== "")
-        hints.model = body.model;
-    if (body.safetyProfile === "read_only" ||
-        body.safetyProfile === "workspace_edit" ||
-        body.safetyProfile === "full_auto") {
-        hints.safetyProfile = body.safetyProfile;
-    }
-    if (body.hints && typeof body.hints === "object") {
-        const raw = body.hints;
-        if (typeof raw.model === "string")
-            hints.model = raw.model;
-        if (raw.taskType === "execute" ||
-            raw.taskType === "plan" ||
-            raw.taskType === "review" ||
-            raw.taskType === "local") {
-            hints.taskType = raw.taskType;
-        }
-        if (typeof raw.preferLargeContext === "boolean") {
-            hints.preferLargeContext = raw.preferLargeContext;
+            const dispatcher = state.dispatchers[route];
+            const breaker = state.router.getBreaker(route);
+            const policy = evaluateRoutePolicy(route, svc, {
+                ...(dispatcher !== undefined ? { dispatcher } : {}),
+                circuitBroken: Boolean(breaker?.isTripped),
+                ...(parsed.hints.safetyProfile !== undefined
+                    ? { requestedSafetyProfile: parsed.hints.safetyProfile }
+                    : {}),
+            });
+            if (policy.skipped)
+                skippedRoutes.push(policy.skipped);
+            if (!policy.blocked)
+                routes.push(route);
         }
-        if (raw.safetyProfile === "read_only" ||
-            raw.safetyProfile === "workspace_edit" ||
-            raw.safetyProfile === "full_auto") {
-            hints.safetyProfile = raw.safetyProfile;
+        return { routes, skippedRoutes };
+    };
+    if (parsed.stream) {
+        // Resolve fanout targets BEFORE writing SSE headers.
+        //
+        // eligibleRoutes throws BadRequestError for an unknown route, but it
+        // was called after writeHead — so headersSent was true, the error
+        // handler could only res.end(), and the caller got HTTP 200 with a
+        // zero-byte body. The non-streaming path returns a proper 400 with
+        // the valid ids. Same input, two answers, again.
+        // Default to every dispatchable route when `models` is omitted,
+        // exactly as the non-streaming branch does. Streaming passed
+        // parsed.models straight through, so {"mode":"fanout","stream":true}
+        // with no models fanned out to ZERO routes and reported success —
+        // content "[]", empty skippedRoutes, HTTP 200.
+        const preSelected = parsed.mode === "fanout"
+            ? eligibleRoutes(parsed.models.length > 0
+                ? parsed.models
+                : Object.keys(state.config.services).filter((route) => route in state.dispatchers))
+            : undefined;
+        res.writeHead(200, {
+            "content-type": "text/event-stream; charset=utf-8",
+            "cache-control": "no-cache",
+            connection: "keep-alive",
+        });
+        sse.started = true;
+        if (parsed.mode === "fanout") {
+            const selected = preSelected;
+            const rows = await runFanoutArms(state.router, selected.routes, parsed);
+            writeSse(res, sseContent(JSON.stringify(rows), {
+                harness_dispatch: {
+                    mode: "fanout",
+                    skippedRoutes: selected.skippedRoutes,
+                    ...(parsed.workingDirWarning !== undefined
+                        ? { warning: parsed.workingDirWarning }
+                        : {}),
+                },
+            }));
         }
-        if (raw.workspacePolicy === "shared" ||
-            raw.workspacePolicy === "shared_locked" ||
-            raw.workspacePolicy === "copy" ||
-            raw.workspacePolicy === "git_worktree") {
-            hints.workspacePolicy = raw.workspacePolicy;
+        else {
+            for await (const { event, decision } of state.router.stream(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 })) {
+                if (event.type === "stdout") {
+                    writeSse(res, sseContent(event.chunk, {
+                        harness_dispatch: decision ? { route: decision.service } : undefined,
+                    }));
+                }
+                else if (event.type === "completion" && !event.result.success) {
+                    writeSse(res, {
+                        error: {
+                            message: event.result.error ?? "routing failed",
+                            route: event.result.service,
+                        },
+                    });
+                }
+            }
         }
+        writeSse(res, sseStop());
+        res.write("data: [DONE]\n\n");
+        res.end();
+        return;
     }
-    if (body.workspacePolicy === "shared" ||
-        body.workspacePolicy === "shared_locked" ||
-        body.workspacePolicy === "copy" ||
-        body.workspacePolicy === "git_worktree") {
-        hints.workspacePolicy = body.workspacePolicy;
+    if (parsed.mode === "fanout") {
+        const routes = parsed.models.length > 0
+            ? parsed.models
+            : Object.keys(state.config.services).filter((route) => route in state.dispatchers);
+        const selected = eligibleRoutes(routes);
+        const rows = await runFanoutArms(state.router, selected.routes, parsed);
+        sendJson(res, 200, completionEnvelope(JSON.stringify(rows, null, 2), typeof parsed.hints.model === "string" ? parsed.hints.model : "harness-dispatch", {
+            harness_dispatch: {
+                mode: "fanout",
+                skippedRoutes: selected.skippedRoutes,
+                ...(parsed.workingDirWarning !== undefined
+                    ? { warning: parsed.workingDirWarning }
+                    : {}),
+            },
+        }));
+        return;
     }
-    return hints;
-}
-function parseChatRequest(raw) {
-    if (!raw || typeof raw !== "object") {
-        throw new Error("request body must be a JSON object");
+    // Backed by a persisted job, not a bare in-process await. This
+    // surface's users are curl/CI/cron — exactly the clients that enforce
+    // their own request timeouts — and a direct await meant a client that
+    // gave up mid-run lost the finished result with no way to retrieve
+    // it. The job survives (it runs detached and lands on disk); the
+    // jobId is exposed in the response AND in a header so even a caller
+    // that only captured headers before timing out can recover the
+    // result via `job_status`.
+    const { status: jobStatus, completion } = await startAsyncJobTracked({ holder }, {
+        prompt: parsed.prompt,
+        files: parsed.files,
+        workingDir: parsed.workingDir,
+        hints: parsed.hints,
+    });
+    res.setHeader("x-harness-dispatch-job-id", jobStatus.jobId);
+    await completion;
+    const job = await getAsyncJob(jobStatus.jobId);
+    const result = job.result?.result;
+    const decision = job.result?.decision ?? undefined;
+    if (result === undefined) {
+        // Terminal without a result payload: the runner died or was
+        // orphaned. The job dir still names what happened.
+        sendJson(res, 500, {
+            error: `job ${jobStatus.jobId} ended without a result (status: ${job.status.status}); ` +
+                `check job_status for details`,
+            jobId: jobStatus.jobId,
+        });
+        return;
     }
-    const body = raw;
-    const prompt = typeof body.prompt === "string" && body.prompt.trim()
-        ? body.prompt
-        : messagesToPrompt(body.messages);
-    if (!prompt.trim())
-        throw new Error("messages or prompt is required");
-    const files = Array.isArray(body.files)
-        ? body.files.filter((v) => typeof v === "string")
-        : [];
-    const models = Array.isArray(body.models)
-        ? body.models.filter((v) => typeof v === "string")
-        : [];
-    const resolvedWorkingDir = resolveWorkingDir(typeof body.workingDir === "string" ? body.workingDir : undefined);
-    const warning = workingDirWarning(resolvedWorkingDir);
-    return {
-        prompt,
-        files,
-        workingDir: resolvedWorkingDir.workingDir,
-        ...(warning !== undefined ? { workingDirWarning: warning } : {}),
-        stream: body.stream === true,
-        mode: body.mode === "fanout" ? "fanout" : "single",
-        models,
-        hints: parseHints(body),
-    };
+    sendJson(res, 200, completionEnvelope(result.output, decision?.model ?? parsed.hints.model ?? "harness-dispatch", {
+        harness_dispatch: {
+            jobId: jobStatus.jobId,
+            route: result.service,
+            success: result.success,
+            error: result.error,
+            workspace: result.workspace,
+            routing: decision,
+            skippedRoutes: decision?.skippedRoutes ?? result.skippedRoutes,
+            ...(parsed.workingDirWarning !== undefined
+                ? { warning: parsed.workingDirWarning }
+                : {}),
+        },
+    }));
+    return;
 }
-function completionEnvelope(content, model, extra) {
+/**
+ * One SSE content frame.
+ *
+ * The `choices[0].delta` envelope is what an OpenAI-compatible client parses,
+ * and it was written out as a literal at three call sites — which is both how
+ * the deepest nesting in this file appeared (a data shape indented under a
+ * loop inside a branch) and how the streaming and non-streaming fanout
+ * replies drifted apart in the first place. Built in one place now.
+ */
+function sseContent(content, extra) {
     return {
-        id: `chatcmpl-${randomUUID()}`,
-        object: "chat.completion",
-        created: Math.floor(Date.now() / 1000),
-        model,
-        choices: [
-            {
-                index: 0,
-                message: { role: "assistant", content },
-                finish_reason: "stop",
-            },
-        ],
-        ...extra,
+        choices: [{ index: 0, delta: { content }, finish_reason: null }],
+        ...(extra ?? {}),
     };
 }
+/** The terminal frame every stream ends with, before `[DONE]`. */
+function sseStop() {
+    return { choices: [{ index: 0, delta: {}, finish_reason: "stop" }] };
+}
 function writeSse(res, payload) {
     res.write(`data: ${JSON.stringify(payload)}\n\n`);
 }
@@ -190,9 +283,16 @@ export async function startHttpServer(opts = {}) {
         sendJson(res, 401, { error: "unauthorized" });
         return false;
     };
+    // A bare IPv6 host must be bracketed to be legal inside a URL:
+    // new URL("/mcp", "http://::1") throws "Invalid URL", which turned EVERY
+    // request to a server bound on ::1 into a 500 — the bind succeeded and the
+    // loopback check blessed the address, so nothing else ever caught it.
+    const urlBase = `http://${host.includes(":") && !host.startsWith("[") ? `[${host}]` : host}`;
     const http = createServer(async (req, res) => {
+        // Shared with handleChatCompletions, read by the catch below.
+        const sse = { started: false };
         try {
-            const url = new URL(req.url ?? "/", `http://${host}`);
+            const url = new URL(req.url ?? "/", urlBase);
             if (url.pathname === "/v1/models" && req.method === "GET") {
                 if (!requireAuth(req, res))
                     return;
@@ -244,161 +344,7 @@ export async function startHttpServer(opts = {}) {
                     return;
                 await reloader.maybeReload();
                 const parsed = parseChatRequest(await readJson(req));
-                const state = holder.state;
-                if (parsed.mode === "fanout") {
-                    const fanoutSafetyProfile = parsed.hints.safetyProfile ?? "read_only";
-                    if (fanoutSafetyProfile !== "read_only" &&
-                        (parsed.hints.workspacePolicy === undefined ||
-                            !isIsolatedWorkspacePolicy(parsed.hints.workspacePolicy))) {
-                        sendJson(res, 400, {
-                            error: {
-                                message: "write-capable fanout requires workspacePolicy=copy or workspacePolicy=git_worktree; use read_only fanout or run single-route workspace_edit",
-                                code: "workspace_isolation_required",
-                            },
-                        });
-                        return;
-                    }
-                    parsed.hints.safetyProfile = fanoutSafetyProfile;
-                }
-                const eligibleRoutes = (requestedRoutes) => {
-                    const routes = [];
-                    const skippedRoutes = [];
-                    for (const route of requestedRoutes) {
-                        const svc = state.config.services[route];
-                        if (!svc)
-                            continue;
-                        const dispatcher = state.dispatchers[route];
-                        const breaker = state.router.getBreaker(route);
-                        const policy = evaluateRoutePolicy(route, svc, {
-                            ...(dispatcher !== undefined ? { dispatcher } : {}),
-                            circuitBroken: Boolean(breaker?.isTripped),
-                            ...(parsed.hints.safetyProfile !== undefined
-                                ? { requestedSafetyProfile: parsed.hints.safetyProfile }
-                                : {}),
-                        });
-                        if (policy.skipped)
-                            skippedRoutes.push(policy.skipped);
-                        if (!policy.blocked)
-                            routes.push(route);
-                    }
-                    return { routes, skippedRoutes };
-                };
-                if (parsed.stream) {
-                    res.writeHead(200, {
-                        "content-type": "text/event-stream; charset=utf-8",
-                        "cache-control": "no-cache",
-                        connection: "keep-alive",
-                    });
-                    if (parsed.mode === "fanout") {
-                        const selected = eligibleRoutes(parsed.models);
-                        const results = await Promise.all(selected.routes.map((route) => state.router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
-                            ...(parsed.hints.safetyProfile !== undefined
-                                ? { safetyProfile: parsed.hints.safetyProfile }
-                                : {}),
-                            ...(parsed.hints.workspacePolicy !== undefined
-                                ? { workspacePolicy: parsed.hints.workspacePolicy }
-                                : {}),
-                            ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
-                        })));
-                        writeSse(res, {
-                            choices: [
-                                {
-                                    index: 0,
-                                    delta: {
-                                        content: JSON.stringify(results.map((r) => ({
-                                            route: r.result.service,
-                                            output: r.result.output,
-                                            workspace: r.result.workspace,
-                                        }))),
-                                    },
-                                    finish_reason: null,
-                                },
-                            ],
-                            harness_dispatch: {
-                                mode: "fanout",
-                                skippedRoutes: selected.skippedRoutes,
-                                ...(parsed.workingDirWarning !== undefined
-                                    ? { warning: parsed.workingDirWarning }
-                                    : {}),
-                            },
-                        });
-                    }
-                    else {
-                        for await (const { event, decision } of state.router.stream(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 })) {
-                            if (event.type === "stdout") {
-                                writeSse(res, {
-                                    choices: [
-                                        {
-                                            index: 0,
-                                            delta: { content: event.chunk },
-                                            finish_reason: null,
-                                        },
-                                    ],
-                                    harness_dispatch: decision ? { route: decision.service } : undefined,
-                                });
-                            }
-                            else if (event.type === "completion" && !event.result.success) {
-                                writeSse(res, {
-                                    error: {
-                                        message: event.result.error ?? "routing failed",
-                                        route: event.result.service,
-                                    },
-                                });
-                            }
-                        }
-                    }
-                    writeSse(res, {
-                        choices: [{ index: 0, delta: {}, finish_reason: "stop" }],
-                    });
-                    res.write("data: [DONE]\n\n");
-                    res.end();
-                    return;
-                }
-                if (parsed.mode === "fanout") {
-                    const routes = parsed.models.length > 0
-                        ? parsed.models
-                        : Object.keys(state.config.services).filter((route) => route in state.dispatchers);
-                    const selected = eligibleRoutes(routes);
-                    const results = await Promise.all(selected.routes.map((route) => state.router.routeTo(route, parsed.prompt, parsed.files, parsed.workingDir, {
-                        ...(parsed.hints.safetyProfile !== undefined
-                            ? { safetyProfile: parsed.hints.safetyProfile }
-                            : {}),
-                        ...(parsed.hints.workspacePolicy !== undefined
-                            ? { workspacePolicy: parsed.hints.workspacePolicy }
-                            : {}),
-                        ...(parsed.hints.taskType !== undefined ? { taskType: parsed.hints.taskType } : {}),
-                    })));
-                    sendJson(res, 200, completionEnvelope(JSON.stringify(results.map((r) => ({
-                        route: r.result.service,
-                        success: r.result.success,
-                        output: r.result.output,
-                        error: r.result.error,
-                        workspace: r.result.workspace,
-                    })), null, 2), typeof parsed.hints.model === "string" ? parsed.hints.model : "harness-dispatch", {
-                        harness_dispatch: {
-                            mode: "fanout",
-                            skippedRoutes: selected.skippedRoutes,
-                            ...(parsed.workingDirWarning !== undefined
-                                ? { warning: parsed.workingDirWarning }
-                                : {}),
-                        },
-                    }));
-                    return;
-                }
-                const { result, decision } = await state.router.route(parsed.prompt, parsed.files, parsed.workingDir, { hints: parsed.hints, maxFallbacks: 2 });
-                sendJson(res, 200, completionEnvelope(result.output, decision?.model ?? parsed.hints.model ?? "harness-dispatch", {
-                    harness_dispatch: {
-                        route: result.service,
-                        success: result.success,
-                        error: result.error,
-                        workspace: result.workspace,
-                        routing: decision,
-                        skippedRoutes: decision?.skippedRoutes ?? result.skippedRoutes,
-                        ...(parsed.workingDirWarning !== undefined
-                            ? { warning: parsed.workingDirWarning }
-                            : {}),
-                    },
-                }));
+                await handleChatCompletions(holder, parsed, res, sse);
                 return;
             }
             if (url.pathname === mcpRoute) {
@@ -439,10 +385,27 @@ export async function startHttpServer(opts = {}) {
             sendText(res, 404, "not found");
         }
         catch (err) {
-            if (!res.headersSent) {
+            if (sse.started) {
+                // Mid-stream failure: the client already holds a 200 and possibly
+                // partial frames, and a bare end() made a truncated stream
+                // indistinguishable from a complete one. Emit an error frame and the
+                // stream terminator so the caller can tell.
+                try {
+                    writeSse(res, { error: { message: err instanceof Error ? err.message : String(err) } });
+                    res.write("data: [DONE]\n\n");
+                }
+                catch {
+                    // Socket already gone; nothing left to tell it.
+                }
+                res.end();
+            }
+            else if (!res.headersSent) {
                 if (err instanceof PayloadTooLargeError) {
                     sendJson(res, 413, { error: err.message });
                 }
+                else if (err instanceof BadRequestError) {
+                    sendJson(res, 400, { error: err.message });
+                }
                 else {
                     sendJson(res, 500, { error: err instanceof Error ? err.message : String(err) });
                 }