stageflow 0.2.0 → 0.8.0

package/dist/server/http.js

@@ -1,54 +1,21 @@
-import { createServer } from "node:http";
 import { readFile, access } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
-import { localhostHostValidation, localhostOriginValidation, } from "@modelcontextprotocol/node";
 import { getCredentialSourceSettings, setCredentialSource, } from "../agent/providerAuth.js";
 import { handleProviderRoutes, providerAuthErrorBody, } from "./providerRoutes.js";
 import { createPipeline, parseCreatePipelineBody } from "../config/createPipeline.js";
 import { createStage, parseCreateStageBody } from "../config/createStage.js";
-import { listModels, listPipelines, listStages, listTasks, } from "../config/listConfig.js";
+import { browseCatalog } from "../config/browseCatalog.js";
 import { listExtensions } from "../config/listExtensions.js";
 import { listSkills } from "../config/listSkills.js";
 import { readRunArtifact } from "../mcp/readArtifact.js";
-import { handleMcpHttpRequest } from "../mcp/server.js";
-import { createRunStore } from "../runstore/createStore.js";
-import { RunManager, } from "../runtime/runManager.js";
+import { resolveStageflowContext } from "../project/resolveStageflowContext.js";
 import { INVALID_SLOT_COUNT_MESSAGE, parseSlotCount, } from "../runtime/settingsFile.js";
 import { isTaskFile } from "../runtime/taskInput.js";
 import { parseAskOperatorAnswer } from "../tools/askOperator.js";
-const DEFAULT_PORT = 3847;
-function json(res, status, body) {
-    const payload = JSON.stringify(body);
-    res.writeHead(status, {
-        "Content-Type": "application/json; charset=utf-8",
-        "Content-Length": Buffer.byteLength(payload),
-    });
-    res.end(payload);
-}
-function startFailureBody(result) {
-    const { ok: _ok, status: _status, reason, ...rest } = result;
-    return { error: reason, ...rest };
-}
-function inferRetryStageErrorCode(reason) {
-    if (/retry already in progress/i.test(reason))
-        return "retry_in_progress";
-    if (/waiting for input/i.test(reason))
-        return "hitl_not_retriable";
-    if (/already has active orchestration/i.test(reason))
-        return "run_not_retryable";
-    if (/run is not failed/i.test(reason))
-        return "run_not_retryable";
-    if (/stage is not failed/i.test(reason))
-        return "stage_not_failed";
-    return undefined;
-}
-function retryStageFailureBody(result) {
-    const { ok: _ok, status: _status, reason, ...rest } = result;
-    const code = inferRetryStageErrorCode(reason);
-    return { error: reason, ...(code ? { code } : {}), ...rest };
-}
+import { bootstrapStageflowHost, } from "./bootstrap.js";
+import { createHttpHost, DEFAULT_PORT, json, } from "./createHttpHost.js";
+import { mapRetryStageFailure, mapStartFailure } from "./operatorResults.js";
 function textPlain(res, status, body) {
     res.writeHead(status, {
         "Content-Type": "text/plain; charset=utf-8",
@@ -202,360 +169,338 @@ export function defaultUiDistDir() {
     return path.resolve(here, "../ui");
 }
 export async function startUiServer(options) {
-    const cwd = options.cwd ?? process.cwd();
-    const agentDir = options.agentDir ?? getAgentDir();
-    const rootDir = options.rootDir ?? cwd;
     const host = options.host ?? "127.0.0.1";
     const port = options.port ?? DEFAULT_PORT;
-    const providerAuthContext = options.providerAuthContext;
     const uiDistDir = options.uiDistDir ?? defaultUiDistDir();
-    const store = options.store ??
-        createRunStore({ rootDir, kind: options.storeKind });
-    const manager = new RunManager({
-        agent: options.agent,
-        cwd,
-        store,
-        maxConcurrent: options.maxConcurrent,
-        operatorCatalog: { cwd, agentDir },
-    });
-    await manager.attachWaitingStages();
-    await manager.reconcileOrphanedStages();
-    const validateMcpHost = localhostHostValidation();
-    const validateMcpOrigin = localhostOriginValidation();
-    const server = createServer(async (req, res) => {
-        const method = req.method ?? "GET";
-        const url = new URL(req.url ?? "/", `http://${host}:${port}`);
-        const pathname = url.pathname;
-        if (pathname === "/mcp") {
-            if (!validateMcpHost(req, res) || !validateMcpOrigin(req, res)) {
-                return;
+    const boot = await bootstrapStageflowHost(options);
+    const { manager, store, cwd, agentDir } = boot;
+    const providerAuthContext = boot.providerAuthContext;
+    return createHttpHost({
+        boot,
+        host,
+        port,
+        routes: async ({ req, res, url, pathname, method }) => {
+            if (isMutatingApi(method, pathname)) {
+                if (!assertLoopbackHttpAccess(req, res)) {
+                    return true;
+                }
+                if (isCredentialMutatingApi(method, pathname) &&
+                    !assertCredentialMutatingOrigin(req, res)) {
+                    return true;
+                }
             }
             try {
-                await handleMcpHttpRequest(req, res, { manager, store, cwd });
-            }
-            catch (err) {
-                if (!res.headersSent) {
-                    res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
-                    res.end(err instanceof Error ? err.message : String(err));
+                if (method === "GET" && pathname === "/api/runs") {
+                    json(res, 200, { runs: await store.listRuns() });
+                    return true;
                 }
-            }
-            return;
-        }
-        if (isMutatingApi(method, pathname)) {
-            if (!assertLoopbackHttpAccess(req, res)) {
-                return;
-            }
-            if (isCredentialMutatingApi(method, pathname) &&
-                !assertCredentialMutatingOrigin(req, res)) {
-                return;
-            }
-        }
-        try {
-            if (method === "GET" && pathname === "/api/runs") {
-                json(res, 200, { runs: await store.listRuns() });
-                return;
-            }
-            const artifactMatch = pathname.match(/^\/api\/runs\/([^/]+)\/artifact$/);
-            if (method === "GET" && artifactMatch) {
-                const runId = decodeURIComponent(artifactMatch[1] ?? "");
-                const artifactPath = url.searchParams.get("path");
-                if (artifactPath === null || artifactPath.trim().length === 0) {
-                    json(res, 400, { error: "path query parameter is required" });
-                    return;
+                const artifactMatch = pathname.match(/^\/api\/runs\/([^/]+)\/artifact$/);
+                if (method === "GET" && artifactMatch) {
+                    const runId = decodeURIComponent(artifactMatch[1] ?? "");
+                    const artifactPath = url.searchParams.get("path");
+                    if (artifactPath === null || artifactPath.trim().length === 0) {
+                        json(res, 400, { error: "path query parameter is required" });
+                        return true;
+                    }
+                    try {
+                        const content = await readRunArtifact(store, runId, artifactPath);
+                        textPlain(res, 200, content);
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        if (message === "Artifact path denied") {
+                            json(res, 403, { error: message });
+                            return true;
+                        }
+                        const notFound = message.startsWith("Run not found") ||
+                            message.startsWith("Artifact not found") ||
+                            /no such|not found/i.test(message);
+                        json(res, notFound ? 404 : 400, { error: message });
+                    }
+                    return true;
+                }
+                if (method === "GET" && pathname.startsWith("/api/runs/")) {
+                    const rest = pathname.slice("/api/runs/".length);
+                    if (rest && !rest.includes("/")) {
+                        try {
+                            json(res, 200, await store.readRun(decodeURIComponent(rest)));
+                        }
+                        catch (err) {
+                            json(res, 404, {
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                        }
+                        return true;
+                    }
                 }
-                try {
-                    const content = await readRunArtifact(store, runId, artifactPath);
-                    textPlain(res, 200, content);
+                if (method === "POST" && pathname === "/api/runs") {
+                    const body = (await readJsonBody(req));
+                    if (typeof body.pipeline !== "string" ||
+                        !body.pipeline.trim() ||
+                        body.task === undefined) {
+                        json(res, 400, { error: "task and pipeline are required" });
+                        return true;
+                    }
+                    if (typeof body.task !== "string" && !isTaskFile(body.task)) {
+                        json(res, 400, {
+                            error: "task must be a path string or TaskFile object (id and goal required)",
+                        });
+                        return true;
+                    }
+                    const result = await manager.startRun({
+                        task: body.task,
+                        pipeline: body.pipeline.trim(),
+                    });
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, mapStartFailure(result));
+                        return true;
+                    }
+                    json(res, 202, { runId: result.runId });
+                    return true;
                 }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    if (message === "Artifact path denied") {
-                        json(res, 403, { error: message });
-                        return;
+                if (method === "POST" && pathname.match(/^\/api\/runs\/[^/]+\/rerun$/)) {
+                    const runId = decodeURIComponent(pathname.split("/")[3] ?? "");
+                    const result = await manager.rerun(runId);
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, mapStartFailure(result));
+                        return true;
                     }
-                    const notFound = message.startsWith("Run not found") ||
-                        message.startsWith("Artifact not found") ||
-                        /no such|not found/i.test(message);
-                    json(res, notFound ? 404 : 400, { error: message });
+                    json(res, 202, { runId: result.runId });
+                    return true;
                 }
-                return;
-            }
-            if (method === "GET" && pathname.startsWith("/api/runs/")) {
-                const rest = pathname.slice("/api/runs/".length);
-                if (rest && !rest.includes("/")) {
+                const answerMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/answer$/);
+                if (method === "POST" && answerMatch) {
+                    const runId = decodeURIComponent(answerMatch[1] ?? "");
+                    const stageId = decodeURIComponent(answerMatch[2] ?? "");
+                    let answer;
                     try {
-                        json(res, 200, await store.readRun(decodeURIComponent(rest)));
+                        answer = parseAskOperatorAnswer(await readJsonBody(req));
                     }
                     catch (err) {
-                        json(res, 404, {
+                        json(res, 400, {
                             error: err instanceof Error ? err.message : String(err),
                         });
+                        return true;
                     }
-                    return;
-                }
-            }
-            if (method === "POST" && pathname === "/api/runs") {
-                const body = (await readJsonBody(req));
-                if (typeof body.pipeline !== "string" ||
-                    !body.pipeline.trim() ||
-                    body.task === undefined) {
-                    json(res, 400, { error: "task and pipeline are required" });
-                    return;
+                    const result = await manager.deliverAnswer(runId, stageId, answer);
+                    if (!result.ok) {
+                        json(res, result.status, { error: result.reason });
+                        return true;
+                    }
+                    json(res, 202, { ok: true });
+                    return true;
                 }
-                if (typeof body.task !== "string" && !isTaskFile(body.task)) {
-                    json(res, 400, {
-                        error: "task must be a path string or TaskFile object (id and goal required)",
+                const retryMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/retry$/);
+                if (method === "POST" && retryMatch) {
+                    await readJsonBody(req);
+                    const runId = decodeURIComponent(retryMatch[1] ?? "");
+                    const stageId = decodeURIComponent(retryMatch[2] ?? "");
+                    const result = await manager.retryStage(runId, stageId);
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, mapRetryStageFailure(result));
+                        return true;
+                    }
+                    json(res, 202, {
+                        runId: result.runId,
+                        stageId: result.stageId,
+                        attemptIndex: result.attemptIndex,
                     });
-                    return;
-                }
-                const result = await manager.startRun({
-                    task: body.task,
-                    pipeline: body.pipeline.trim(),
-                });
-                if (!result.ok) {
-                    json(res, result.status ?? 500, startFailureBody(result));
-                    return;
-                }
-                json(res, 202, { runId: result.runId });
-                return;
-            }
-            if (method === "POST" && pathname.match(/^\/api\/runs\/[^/]+\/rerun$/)) {
-                const runId = decodeURIComponent(pathname.split("/")[3] ?? "");
-                const result = await manager.rerun(runId);
-                if (!result.ok) {
-                    json(res, result.status ?? 500, startFailureBody(result));
-                    return;
-                }
-                json(res, 202, { runId: result.runId });
-                return;
-            }
-            const answerMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/answer$/);
-            if (method === "POST" && answerMatch) {
-                const runId = decodeURIComponent(answerMatch[1] ?? "");
-                const stageId = decodeURIComponent(answerMatch[2] ?? "");
-                let answer;
-                try {
-                    answer = parseAskOperatorAnswer(await readJsonBody(req));
+                    return true;
                 }
-                catch (err) {
-                    json(res, 400, {
-                        error: err instanceof Error ? err.message : String(err),
+                const abandonMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/abandon$/);
+                if (method === "POST" && abandonMatch) {
+                    await readJsonBody(req);
+                    const runId = decodeURIComponent(abandonMatch[1] ?? "");
+                    const stageId = decodeURIComponent(abandonMatch[2] ?? "");
+                    const result = await manager.abandonStage(runId, stageId);
+                    if (!result.ok) {
+                        json(res, result.status ?? 500, {
+                            error: result.reason,
+                        });
+                        return true;
+                    }
+                    json(res, 202, {
+                        ok: true,
+                        runId: result.runId,
+                        stageId: result.stageId,
                     });
-                    return;
+                    return true;
                 }
-                const result = await manager.deliverAnswer(runId, stageId, answer);
-                if (!result.ok) {
-                    json(res, result.status, { error: result.reason });
-                    return;
+                if (method === "GET" && pathname === "/api/tasks") {
+                    const catalog = await browseCatalog(cwd);
+                    json(res, 200, { tasks: catalog.tasks });
+                    return true;
                 }
-                json(res, 202, { ok: true });
-                return;
-            }
-            const retryMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/retry$/);
-            if (method === "POST" && retryMatch) {
-                await readJsonBody(req);
-                const runId = decodeURIComponent(retryMatch[1] ?? "");
-                const stageId = decodeURIComponent(retryMatch[2] ?? "");
-                const result = await manager.retryStage(runId, stageId);
-                if (!result.ok) {
-                    json(res, result.status ?? 500, retryStageFailureBody(result));
-                    return;
+                if (method === "GET" && pathname === "/api/pipelines") {
+                    const catalog = await browseCatalog(cwd);
+                    json(res, 200, { pipelines: catalog.pipelines });
+                    return true;
                 }
-                json(res, 202, {
-                    runId: result.runId,
-                    stageId: result.stageId,
-                    attemptIndex: result.attemptIndex,
-                });
-                return;
-            }
-            const abandonMatch = pathname.match(/^\/api\/runs\/([^/]+)\/stages\/([^/]+)\/abandon$/);
-            if (method === "POST" && abandonMatch) {
-                await readJsonBody(req);
-                const runId = decodeURIComponent(abandonMatch[1] ?? "");
-                const stageId = decodeURIComponent(abandonMatch[2] ?? "");
-                const result = await manager.abandonStage(runId, stageId);
-                if (!result.ok) {
-                    json(res, result.status ?? 500, {
-                        error: result.reason,
+                if (method === "GET" && pathname === "/api/stages") {
+                    json(res, 404, {
+                        error: "Global stage library removed; stages are pipeline-scoped",
                     });
-                    return;
-                }
-                json(res, 202, {
-                    ok: true,
-                    runId: result.runId,
-                    stageId: result.stageId,
-                });
-                return;
-            }
-            if (method === "GET" && pathname === "/api/tasks") {
-                json(res, 200, { tasks: await listTasks(cwd) });
-                return;
-            }
-            if (method === "GET" && pathname === "/api/pipelines") {
-                json(res, 200, { pipelines: await listPipelines(cwd) });
-                return;
-            }
-            if (method === "GET" && pathname === "/api/stages") {
-                json(res, 200, { stages: await listStages(cwd) });
-                return;
-            }
-            if (method === "POST" && pathname === "/api/stages") {
-                let body;
-                try {
-                    body = await readJsonBody(req);
-                }
-                catch {
-                    json(res, 400, { error: "Invalid JSON body" });
-                    return;
-                }
-                const parsed = parseCreateStageBody(body);
-                if ("ok" in parsed) {
-                    json(res, parsed.status, { error: parsed.error });
-                    return;
+                    return true;
                 }
-                const result = await createStage(cwd, parsed);
-                if (!result.ok) {
-                    json(res, result.status, { error: result.error });
-                    return;
+                if (method === "POST" && pathname === "/api/stages") {
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        json(res, 400, { error: "Invalid JSON body" });
+                        return true;
+                    }
+                    const parsed = parseCreateStageBody(body);
+                    if ("ok" in parsed) {
+                        json(res, parsed.status, { error: parsed.error });
+                        return true;
+                    }
+                    const ctx = await resolveStageflowContext(cwd);
+                    if (!ctx.isGitProject) {
+                        json(res, 400, {
+                            error: "Project root not found; initialize stageflow.yaml in a git repo",
+                        });
+                        return true;
+                    }
+                    const result = await createStage(ctx.projectRoot, parsed);
+                    if (!result.ok) {
+                        json(res, result.status, { error: result.error });
+                        return true;
+                    }
+                    json(res, 201, result.stage);
+                    return true;
                 }
-                json(res, 201, result.stage);
-                return;
-            }
-            if (method === "POST" && pathname === "/api/pipelines") {
-                let body;
-                try {
-                    body = await readJsonBody(req);
+                if (method === "POST" && pathname === "/api/pipelines") {
+                    let body;
+                    try {
+                        body = await readJsonBody(req);
+                    }
+                    catch {
+                        json(res, 400, { error: "Invalid JSON body" });
+                        return true;
+                    }
+                    const parsed = parseCreatePipelineBody(body);
+                    if ("ok" in parsed) {
+                        json(res, parsed.status, { error: parsed.error });
+                        return true;
+                    }
+                    const ctx = await resolveStageflowContext(cwd);
+                    if (!ctx.isGitProject) {
+                        json(res, 400, {
+                            error: "Project root not found; initialize stageflow.yaml in a git repo",
+                        });
+                        return true;
+                    }
+                    const result = await createPipeline(ctx.projectRoot, parsed);
+                    if (!result.ok) {
+                        json(res, result.status, { error: result.error });
+                        return true;
+                    }
+                    json(res, 201, result.pipeline);
+                    return true;
                 }
-                catch {
-                    json(res, 400, { error: "Invalid JSON body" });
-                    return;
+                if (method === "GET" && pathname === "/api/models") {
+                    const catalog = await browseCatalog(cwd);
+                    json(res, 200, { models: catalog.models });
+                    return true;
                 }
-                const parsed = parseCreatePipelineBody(body);
-                if ("ok" in parsed) {
-                    json(res, parsed.status, { error: parsed.error });
-                    return;
+                if (await handleProviderRoutes(req, res, {
+                    cwd,
+                    readJsonBody,
+                    json,
+                    providerAuthContext,
+                })) {
+                    return true;
                 }
-                const result = await createPipeline(cwd, parsed);
-                if (!result.ok) {
-                    json(res, result.status, { error: result.error });
-                    return;
+                if (method === "GET" && pathname === "/api/skills") {
+                    json(res, 200, await listSkills({ cwd, agentDir }));
+                    return true;
                 }
-                json(res, 201, result.pipeline);
-                return;
-            }
-            if (method === "GET" && pathname === "/api/models") {
-                json(res, 200, { models: await listModels(cwd) });
-                return;
-            }
-            if (await handleProviderRoutes(req, res, {
-                cwd,
-                readJsonBody,
-                json,
-                providerAuthContext,
-            })) {
-                return;
-            }
-            if (method === "GET" && pathname === "/api/skills") {
-                json(res, 200, await listSkills({ cwd, agentDir }));
-                return;
-            }
-            if (method === "GET" && pathname === "/api/extensions") {
-                json(res, 200, await listExtensions({ cwd, agentDir }));
-                return;
-            }
-            if (method === "GET" && pathname === "/api/health") {
-                json(res, 200, manager.getHealth());
-                return;
-            }
-            if (method === "GET" && pathname === "/api/settings") {
-                const health = manager.getHealth();
-                const credential = getCredentialSourceSettings(cwd);
-                json(res, 200, {
-                    maxConcurrent: health.maxConcurrent,
-                    ...credential,
-                });
-                return;
-            }
-            if (method === "POST" && pathname === "/api/settings") {
-                let body;
-                try {
-                    body = await readJsonBody(req);
+                if (method === "GET" && pathname === "/api/extensions") {
+                    json(res, 200, await listExtensions({ cwd, agentDir }));
+                    return true;
                 }
-                catch {
-                    json(res, 400, { error: "Invalid JSON body" });
-                    return;
+                if (method === "GET" && pathname === "/api/health") {
+                    json(res, 200, manager.getHealth());
+                    return true;
                 }
-                const record = body !== null && typeof body === "object" && !Array.isArray(body)
-                    ? body
-                    : {};
-                const hasMax = Object.prototype.hasOwnProperty.call(record, "maxConcurrent");
-                const hasCredentialSource = Object.prototype.hasOwnProperty.call(record, "credentialSource");
-                if (!hasMax && !hasCredentialSource) {
-                    json(res, 400, {
-                        error: "maxConcurrent or credentialSource is required",
+                if (method === "GET" && pathname === "/api/settings") {
+                    const health = manager.getHealth();
+                    const credential = getCredentialSourceSettings(cwd);
+                    json(res, 200, {
+                        maxConcurrent: health.maxConcurrent,
+                        ...credential,
                     });
-                    return;
-                }
-                let health = manager.getHealth();
-                if (hasMax) {
-                    const n = parseSlotCount(record.maxConcurrent);
-                    if (n === undefined) {
-                        json(res, 400, { error: INVALID_SLOT_COUNT_MESSAGE });
-                        return;
-                    }
-                    health = manager.setMaxConcurrent(n);
+                    return true;
                 }
-                let credential = getCredentialSourceSettings(cwd);
-                if (hasCredentialSource) {
+                if (method === "POST" && pathname === "/api/settings") {
+                    let body;
                     try {
-                        credential = setCredentialSource(cwd, record.credentialSource);
+                        body = await readJsonBody(req);
                     }
-                    catch (err) {
-                        const mapped = providerAuthErrorBody(err);
-                        json(res, mapped.status, mapped.body);
-                        return;
+                    catch {
+                        json(res, 400, { error: "Invalid JSON body" });
+                        return true;
+                    }
+                    const record = body !== null && typeof body === "object" && !Array.isArray(body)
+                        ? body
+                        : {};
+                    const hasMax = Object.prototype.hasOwnProperty.call(record, "maxConcurrent");
+                    const hasCredentialSource = Object.prototype.hasOwnProperty.call(record, "credentialSource");
+                    if (!hasMax && !hasCredentialSource) {
+                        json(res, 400, {
+                            error: "maxConcurrent or credentialSource is required",
+                        });
+                        return true;
                     }
+                    let health = manager.getHealth();
+                    if (hasMax) {
+                        const n = parseSlotCount(record.maxConcurrent);
+                        if (n === undefined) {
+                            json(res, 400, { error: INVALID_SLOT_COUNT_MESSAGE });
+                            return true;
+                        }
+                        health = manager.setMaxConcurrent(n);
+                    }
+                    let credential = getCredentialSourceSettings(cwd);
+                    if (hasCredentialSource) {
+                        try {
+                            credential = setCredentialSource(cwd, record.credentialSource);
+                        }
+                        catch (err) {
+                            const mapped = providerAuthErrorBody(err);
+                            json(res, mapped.status, mapped.body);
+                            return true;
+                        }
+                    }
+                    json(res, 200, {
+                        ...health,
+                        ...credential,
+                    });
+                    return true;
                 }
-                json(res, 200, {
-                    ...health,
-                    ...credential,
-                });
-                return;
-            }
-            if (method === "GET") {
-                const served = await serveStatic(res, uiDistDir, pathname);
-                if (served)
-                    return;
-                json(res, 404, {
-                    error: "UI not built. Run npm run ui:build, or use Vite dev proxy.",
-                });
-                return;
+                if (method === "GET") {
+                    const served = await serveStatic(res, uiDistDir, pathname);
+                    if (served)
+                        return true;
+                    json(res, 404, {
+                        error: "UI not built. Run npm run ui:build, or use Vite dev proxy.",
+                    });
+                    return true;
+                }
+                json(res, 404, { error: "Not found" });
+                return true;
             }
-            json(res, 404, { error: "Not found" });
-        }
-        catch (err) {
-            if (!res.headersSent) {
-                json(res, 500, {
-                    error: err instanceof Error ? err.message : String(err),
-                });
+            catch (err) {
+                if (!res.headersSent) {
+                    json(res, 500, {
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                return true;
             }
-        }
-    });
-    await new Promise((resolve, reject) => {
-        server.listen(port, host, () => resolve());
-        server.on("error", reject);
+        },
     });
-    const address = server.address();
-    const boundPort = address && typeof address !== "string" ? address.port : port;
-    const url = `http://${host}:${boundPort}`;
-    return {
-        server,
-        port: boundPort,
-        host,
-        url,
-        mcpUrl: `${url}/mcp`,
-        manager,
-        store,
-    };
 }
 export { DEFAULT_PORT };