@realqiyan/agent-task 0.0.1-rc.1 → 0.0.1-rc.3

package/dist/{coordinator.js → integrations/coordinator/coordinator.js}

@@ -1,9 +1,9 @@
 import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
 import { Type } from "@earendil-works/pi-ai";
 import { createModels } from "@earendil-works/pi-ai/models";
-import { createCoordinatorProvider } from "./coordinator-provider.js";
+import { createCoordinatorProvider } from "./provider.js";
 import { createRegistry, defineExtension, defineTool, Harness, section } from "@earendil-works/pi-durable";
-import { openCoordinatorStorage } from "./coordinator-storage.js";
+import { openCoordinatorStorage } from "./storage.js";
 const instructions = `You advance one persisted task run using the DAG supplied by the caller. External ACP agents do all domain work.
 Start with inspect_run. The nodes, prompts, dependencies and assigned executorIds are already fixed. Do not decompose the task, add nodes, replace the plan or switch executors.
 Use converse to start a pending node only after all direct dependencies have accepted deliveries. Its first turn uses the caller-supplied node prompt. Independent nodes may run concurrently.
@@ -79,7 +79,8 @@ export function createCoordinator(directory, config) {
                 tool({ name: "request_input", description: "Persist a question and suspend this run for human facts. Only after all ACP turns finish. Not permission approval.",
                     parameters: Type.Object({ nodeId: Type.Optional(Type.String()),
                         question: Type.String({ minLength: 1, maxLength: 4000 }), completedWork: Type.String({ minLength: 1, maxLength: 4000 }) }), replay: "unsafe",
-                    execute: async (args) => ({ ...output(actions.ask(args)), control: { terminate: true } }) }),
+                    execute: async (args) => ({ ...output(actions.ask({ ...args, question: args.question.trim(), completedWork: args.completedWork.trim() })),
+                        control: { terminate: true } }) }),
                 tool({ name: "stop_run", description: "Stop without success for an unachievable task. Use request_input for missing user facts.",
                     parameters: Type.Object({ status: Type.Literal("failed"),
                         reason: Type.String({ minLength: 1, maxLength: 4000 }) }), replay: "unsafe",
@@ -87,10 +88,18 @@ export function createCoordinator(directory, config) {
             ],
         }));
         const storage = await openCoordinatorStorage(directory, runId);
-        const harness = await Harness.open(storage, {
-            models, registry,
-            settings: { retry: { enabled: false }, stream: { maxRetries: 0, timeoutMs: 120000 } },
-        }, context);
+        let harness;
+        try {
+            harness = await Harness.open(storage, {
+                models, registry,
+                settings: { retry: { enabled: false }, stream: { maxRetries: 0, timeoutMs: 120000 } },
+            }, context);
+        }
+        catch (error) {
+            // Ownership transfers to Harness only after open succeeds. Storage close is idempotent.
+            await storage.close(context);
+            throw error;
+        }
         // Close rather than mark durable tasks aborted. A safe run may resume its same submission after restart.
         const abort = () => { void harness.close(context).catch(() => { }); };
         signal.addEventListener("abort", abort, { once: true });

package/dist/{coordinator-provider.js → integrations/coordinator/provider.js}

@@ -25,4 +25,4 @@ export function createCoordinatorProvider(config) {
         });
     }
 }
-//# sourceMappingURL=coordinator-provider.js.map
+//# sourceMappingURL=provider.js.map

package/dist/{coordinator-storage.js → integrations/coordinator/storage.js}

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { DatabaseSync } from "../../infrastructure/sqlite.js";
 import { SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
 import { openNodeSqliteDatabase } from "@earendil-works/pi-durable/storage/sqlite/node";
 /** The caller holds the application directory lock. New files initialize; existing files must already match the pinned SDK. */
@@ -40,4 +40,4 @@ export async function openCoordinatorStorage(directory, runId) {
         throw error;
     }
 }
-//# sourceMappingURL=coordinator-storage.js.map
+//# sourceMappingURL=storage.js.map

package/dist/integrations/local-service/control.js

@@ -0,0 +1,33 @@
+import { request } from "node:http";
+import { join } from "node:path";
+import { startupPaths } from "../../configuration/files.js";
+/** Local administrator capability: the socket lives in the private launcher directory. */
+export function controlService(home, action) {
+    startupPaths(home);
+    return new Promise((resolve, reject) => {
+        let timedOut = false;
+        const req = request({ socketPath: join(home, "control.sock"), path: "/" + action, method: "POST" }, res => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => { body += chunk; });
+            res.on("end", () => {
+                if (res.statusCode !== 200) {
+                    reject(new Error("Service unavailable; inspect private logs and startup files"));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    reject(new Error("Invalid launcher response"));
+                }
+            });
+        });
+        req.setTimeout(60_000, () => { timedOut = true; req.destroy(); });
+        req.once("error", () => reject(new Error(timedOut
+            ? "Service control timed out; outcome is unknown, check status before another restart"
+            : "Cannot contact launcher; start the foreground or managed service first")));
+        req.end();
+    });
+}
+//# sourceMappingURL=control.js.map

package/dist/protocol/cli/admin-client.js

@@ -0,0 +1,45 @@
+import { controlService } from "../../integrations/local-service/control.js";
+import { startupPaths } from "../../configuration/files.js";
+import { readEnvironment } from "../../configuration/files.js";
+import { ADMIN_TOKEN_ENV } from "../../configuration/policy.js";
+/** Local CLI transport. Credentials never enter arguments, URLs or diagnostics. */
+export async function connectAdmin(home) {
+    const ready = await controlService(home, "status");
+    if (!ready.consoleUrl)
+        throw new Error("Administrator API is disabled; configure an administrator token while stopped");
+    const url = new URL(ready.consoleUrl);
+    if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.username || url.password) {
+        throw new Error("Invalid local administrator address");
+    }
+    const token = readEnvironment(startupPaths(home).environmentPath)[ADMIN_TOKEN_ENV];
+    if (!token)
+        throw new Error("Administrator credential is unavailable");
+    return {
+        ready,
+        async request(path, input) {
+            let response;
+            try {
+                response = await fetch(url.origin + "/admin/api" + path, {
+                    method: input === undefined ? "GET" : "POST", redirect: "error",
+                    headers: { Authorization: "Bearer " + token,
+                        ...(input === undefined ? {} : { Origin: url.origin, "Content-Type": "application/json" }) },
+                    body: input === undefined ? undefined : JSON.stringify(input), signal: AbortSignal.timeout(60_000),
+                });
+            }
+            catch {
+                throw new Error("Administrator request could not be confirmed; inspect current state before retrying. No offline write was attempted");
+            }
+            let body;
+            try {
+                body = await response.json();
+            }
+            catch {
+                throw new Error("Invalid administrator response");
+            }
+            if (!response.ok)
+                throw new Error(body.error ?? "Administrator request rejected (HTTP " + response.status + ")");
+            return body.data;
+        },
+    };
+}
+//# sourceMappingURL=admin-client.js.map

package/dist/protocol/cli/commands.js

@@ -0,0 +1,394 @@
+import { readFileSync, writeFileSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+import { connectAdmin } from "./admin-client.js";
+import { controlService } from "../../integrations/local-service/control.js";
+const common = "Common: --home ABSOLUTE_DIR --json --help. Writes: --yes for noninteractive confirmation.";
+const help = {
+    config: `config show [--saved | --running]
+config diff
+config edit [--editor EXECUTABLE] [--yes]
+config export --output FILE
+config validate --file FILE
+config apply --file FILE [--yes]
+Drafts contain {editToken, config, approveExecutors}; no credential values.
+Edit tokens expire after 15 minutes or a save/restart. Explicit approvals name executor IDs in the candidate configuration.
+Saving applies on next start; it does not restart the service.`,
+    executor: `executor list [--saved | --running]
+executor show ID [--saved | --running]
+executor add --id ID --type pi|codex|claude|opencode --cwd ABSOLUTE_DIR [--note TEXT] [--yes]
+executor update ID [--id NEW_ID] [--type TYPE] [--cwd ABSOLUTE_DIR] [--note TEXT] [--yes]
+executor remove ID [--yes]
+executor approve ID [--yes]
+executor revoke ID [--yes]
+Changes apply on next start. New registrations are unapproved; changing ID, type or workspace clears approval.
+approve records the administrator's review of native authorization; --yes alone does not grant it.`,
+    coordinator: `coordinator show [--saved | --running]
+coordinator set --provider openai|anthropic|deepseek|openai-compatible --model ID [--yes]
+  Compatible provider also requires: --base-url URL --api-key-env NAME
+  --context-window NUMBER --max-tokens NUMBER [--api openai-completions|openai-responses] [--reasoning true|false]
+coordinator clear [--yes]
+Save the required credential first. Changes apply on next start.`,
+    credential: `credential list
+credential set NAME [--stdin] [--yes]
+credential delete NAME [--yes]
+set reads a hidden terminal prompt or stdin (one trailing newline is removed).
+Values are never accepted as command arguments or printed. Saves apply on next start.
+Service/admin tokens and executor native authentication are not managed here.`,
+    task: `task list [--after NUMBER] [--limit NUMBER]
+task show ID
+task pause ID [--yes]
+task resume ID [--yes]
+task cancel ID [--yes]
+Only future triggers change; current runs continue. Resume does not catch up. Cancel is irreversible for future triggers.`,
+    run: `run list [--task ID] [--after NUMBER] [--limit NUMBER]
+run show ID
+show includes nodes, turns, accepted deliveries, errors, questions and existing replies.`,
+    status: "status\nAuthenticated health, active runs/sessions and pending configuration changes.",
+    restart: "restart\nApply saved settings and verify the new instance. Active ACP sessions close; uncertain work is not replayed.",
+};
+const flags = new Set(["json", "yes", "help", "saved", "running", "stdin"]);
+function parse(args) {
+    const options = {}, positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg.startsWith("--")) {
+            positionals.push(arg);
+            continue;
+        }
+        const key = arg.slice(2);
+        if (Object.hasOwn(options, key))
+            throw new Error("Repeated option: --" + key);
+        if (flags.has(key))
+            options[key] = true;
+        else {
+            const value = args[++i];
+            if (value === undefined || value.startsWith("--"))
+                throw new Error("Missing option value: --" + key);
+            options[key] = value;
+        }
+    }
+    return { options, positionals };
+}
+function text(options, name, required = false) {
+    const value = options[name];
+    if (typeof value === "string")
+        return value;
+    if (required)
+        throw new Error("Required option: --" + name);
+    return undefined;
+}
+function number(options, name, required = false) {
+    const value = text(options, name, required);
+    if (value === undefined)
+        return undefined;
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new Error("Expected integer: --" + name);
+    return Number(value);
+}
+function readJson(path) {
+    try {
+        const value = readFileSync(path, "utf8");
+        if (Buffer.byteLength(value) > 512 * 1024)
+            throw new Error();
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error("Cannot read JSON input (maximum 512 KiB)");
+    }
+}
+function writeDraft(path, value) {
+    writeFileSync(path, JSON.stringify(value, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+}
+async function confirm(options, message) {
+    if (options.yes)
+        return;
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        throw new Error("Noninteractive writes require --yes");
+    const terminal = createInterface({ input: process.stdin, output: process.stderr });
+    try {
+        if (!/^(y|yes)$/i.test((await terminal.question(message + " [y/N] ")).trim()))
+            throw new Error("Cancelled; no change saved");
+    }
+    finally {
+        terminal.close();
+    }
+}
+async function credentialValue(options) {
+    if (options.stdin) {
+        if (process.stdin.isTTY)
+            throw new Error("--stdin requires piped input");
+        const chunks = [];
+        let length = 0;
+        for await (const chunk of process.stdin) {
+            const bytes = Buffer.from(chunk);
+            length += bytes.length;
+            if (length > 65538)
+                throw new Error("Credential input is too large");
+            chunks.push(bytes);
+        }
+        return Buffer.concat(chunks).toString("utf8").replace(/\r?\n$/, "");
+    }
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        throw new Error("Use --stdin to provide a credential without a terminal");
+    const muted = new Writable({ write(_chunk, _encoding, done) { done(); } });
+    const terminal = createInterface({ input: process.stdin, output: muted, terminal: true });
+    process.stderr.write("New credential (hidden): ");
+    try {
+        return await terminal.question("");
+    }
+    finally {
+        terminal.close();
+        muted.end();
+        process.stderr.write("\n");
+    }
+}
+export async function runCli(command, args, resolveHome) {
+    if (!help[command])
+        throw new Error("Unknown command; use agent-task --help");
+    const { options, positionals } = parse(args);
+    if (options.help || (positionals.length === 0 && !["status", "restart"].includes(command))) {
+        console.log("Usage: agent-task " + help[command] + "\n" + common);
+        return;
+    }
+    const [action, id] = positionals;
+    let allowed = [], count = 1;
+    switch (command) {
+        case "status":
+        case "restart":
+            count = 0;
+            break;
+        case "config":
+            if (action === "show")
+                allowed = ["saved", "running"];
+            else if (action === "diff")
+                allowed = [];
+            else if (action === "edit")
+                allowed = ["editor", "yes"];
+            else if (action === "export")
+                allowed = ["output"];
+            else if (action === "validate" || action === "apply")
+                allowed = ["file", ...(action === "apply" ? ["yes"] : [])];
+            else
+                throw new Error("Unknown config action");
+            break;
+        case "executor":
+            if (action === "list" || action === "show") {
+                allowed = ["saved", "running"];
+                count = action === "show" ? 2 : 1;
+            }
+            else if (action === "add" || action === "update") {
+                allowed = ["id", "type", "cwd", "note", "yes"];
+                count = action === "update" ? 2 : 1;
+            }
+            else if (["remove", "approve", "revoke"].includes(action)) {
+                count = 2;
+                allowed = ["yes"];
+            }
+            else
+                throw new Error("Unknown executor action");
+            break;
+        case "coordinator":
+            if (action === "show")
+                allowed = ["saved", "running"];
+            else if (action === "set")
+                allowed = ["provider", "model", "base-url", "api-key-env", "api", "context-window", "max-tokens", "reasoning", "yes"];
+            else if (action === "clear")
+                allowed = ["yes"];
+            else
+                throw new Error("Unknown coordinator action");
+            break;
+        case "credential":
+            if (action === "list")
+                break;
+            if (action !== "set" && action !== "delete")
+                throw new Error("Unknown credential action");
+            count = 2;
+            allowed = action === "set" ? ["stdin", "yes"] : ["yes"];
+            break;
+        case "task":
+        case "run":
+            if (action === "list")
+                allowed = ["after", "limit", ...(command === "run" ? ["task"] : [])];
+            else if (action === "show")
+                count = 2;
+            else if (command === "task" && ["pause", "resume", "cancel"].includes(action)) {
+                count = 2;
+                allowed = ["yes"];
+            }
+            else
+                throw new Error("Unknown " + command + " action");
+    }
+    if (positionals.length !== count)
+        throw new Error("Unexpected or missing arguments; use " + command + " --help");
+    for (const key of Object.keys(options)) {
+        if (!["home", "json", ...allowed].includes(key))
+            throw new Error("Unsupported option: --" + key);
+    }
+    if (options.saved && options.running)
+        throw new Error("Choose either --saved or --running");
+    const home = resolveHome(text(options, "home"));
+    const output = (value) => console.log(JSON.stringify(value, null, options.json ? undefined : 2));
+    if (command === "restart") {
+        output({ event: "restarted", ...await controlService(home, "restart") });
+        return;
+    }
+    if (command === "status") {
+        const ready = await controlService(home, "status");
+        if (!ready.consoleUrl) {
+            output({ event: "healthy", ...ready, adminEnabled: false });
+            return;
+        }
+    }
+    const client = await connectAdmin(home);
+    if (command === "status") {
+        output({ event: "healthy", ...client.ready, ...await client.request("/status") });
+        return;
+    }
+    if (command === "task" || command === "run") {
+        if (action === "list") {
+            const query = new URLSearchParams();
+            for (const key of ["after", "limit"]) {
+                const value = number(options, key);
+                if (value !== undefined)
+                    query.set(key, String(value));
+            }
+            if (text(options, "task"))
+                query.set("taskId", text(options, "task"));
+            output(await client.request("/" + command + "s?" + query));
+        }
+        else if (action === "show")
+            output(await client.request("/" + command + "s/" + encodeURIComponent(id)));
+        else {
+            const task = await client.request("/tasks/" + encodeURIComponent(id));
+            process.stderr.write(JSON.stringify({ action, task }) + "\nOnly future triggers change; current runs continue. Resume does not catch up; cancel cannot be undone.\n");
+            await confirm(options, "Change future triggers?");
+            output(await client.request("/task-update", { id, action }));
+        }
+        return;
+    }
+    const previewAndSave = async (input) => {
+        const preview = await client.request("/settings/validate", input);
+        process.stderr.write(JSON.stringify(preview, null, 2) + "\nLocal validation does not verify model authentication or ACP execution. Saved changes apply on next start.\n");
+        await confirm(options, "Save configuration?");
+        output(await client.request("/settings/config", input));
+    };
+    if (command === "config") {
+        if (action === "diff") {
+            output(await client.request("/settings/diff"));
+            return;
+        }
+        if (action === "validate" || action === "apply") {
+            const input = readJson(text(options, "file", true));
+            if (action === "validate")
+                output(await client.request("/settings/validate", input));
+            else
+                await previewAndSave(input);
+            return;
+        }
+        const view = await client.request("/settings");
+        if (action === "show") {
+            output(options.running ? view.running : view.saved);
+            return;
+        }
+        const draft = { editToken: view.editToken, config: view.saved, approveExecutors: [] };
+        if (action === "export") {
+            const path = text(options, "output", true);
+            writeDraft(path, draft);
+            output({ file: path });
+            return;
+        }
+        if (!process.stdin.isTTY || !process.stderr.isTTY)
+            throw new Error("config edit requires a terminal; use export and apply for noninteractive edits");
+        const editor = text(options, "editor") ?? process.env.VISUAL ?? process.env.EDITOR;
+        if (!editor)
+            throw new Error("Set EDITOR/VISUAL or --editor to an executable path (no shell arguments)");
+        const directory = mkdtempSync(join(tmpdir(), "agent-task-edit-")), file = join(directory, "draft.json");
+        try {
+            writeDraft(file, draft);
+            const result = spawnSync(editor, [file], { stdio: "inherit" });
+            if (result.error || result.status !== 0)
+                throw new Error("Editor failed; no configuration saved");
+            await previewAndSave(readJson(file));
+        }
+        finally {
+            rmSync(directory, { recursive: true, force: true });
+        }
+        return;
+    }
+    const view = await client.request("/settings");
+    if (command === "credential") {
+        if (action === "list") {
+            output(view.credentials);
+            return;
+        }
+        process.stderr.write("Credential " + action + ": " + id + "; applies on next start.\n");
+        await confirm(options, "Save credential change?");
+        const input = { editToken: view.editToken, key: id, action: action === "set" ? "replace" : "delete",
+            ...(action === "set" ? { value: await credentialValue(options) } : {}) };
+        output(await client.request("/settings/credential", input));
+        return;
+    }
+    const selected = options.running ? view.running : view.saved;
+    if (action === "list") {
+        output(selected.executors);
+        return;
+    }
+    if (action === "show") {
+        if (command === "coordinator")
+            output(selected.coordinator ?? null);
+        else {
+            const executor = selected.executors.find(item => item.id === id);
+            if (!executor)
+                throw new Error("Executor not found");
+            output(executor);
+        }
+        return;
+    }
+    let change;
+    if (command === "executor") {
+        if (action === "add" || action === "update") {
+            const fields = {};
+            for (const key of ["id", "type", "cwd", "note"]) {
+                const value = text(options, key, action === "add" && key !== "note");
+                if (value !== undefined)
+                    fields[key] = value;
+            }
+            if (!Object.keys(fields).length)
+                throw new Error("Specify at least one executor field to update");
+            change = action === "add" ? { action: "executor-add", executor: fields } : { action: "executor-update", id, patch: fields };
+        }
+        else
+            change = { action: "executor-" + action, id };
+    }
+    else if (action === "clear")
+        change = { action: "coordinator-clear" };
+    else {
+        const provider = text(options, "provider", true), model = text(options, "model", true);
+        const coordinator = { provider, model };
+        const compatible = provider === "openai-compatible";
+        for (const [flag, field] of [["base-url", "baseUrl"], ["api-key-env", "apiKeyEnv"], ["api", "api"]]) {
+            const value = text(options, flag, compatible && flag !== "api");
+            if (value !== undefined)
+                coordinator[field] = value;
+        }
+        for (const [flag, field] of [["context-window", "contextWindow"], ["max-tokens", "maxTokens"]]) {
+            const value = number(options, flag, compatible);
+            if (value !== undefined)
+                coordinator[field] = value;
+        }
+        const reasoning = text(options, "reasoning");
+        if (reasoning !== undefined) {
+            if (!["true", "false"].includes(reasoning))
+                throw new Error("--reasoning must be true or false");
+            coordinator.reasoning = reasoning === "true";
+        }
+        change = { action: "coordinator-set", coordinator };
+    }
+    const draft = await client.request("/settings/prepare", { editToken: view.editToken, change });
+    await previewAndSave(draft);
+}
+//# sourceMappingURL=commands.js.map

package/dist/{http-auth.js → protocol/http/auth.js}

@@ -6,4 +6,4 @@ export function bearerVerifier(token) {
         return actual.length === expected.length && timingSafeEqual(actual, expected);
     };
 }
-//# sourceMappingURL=http-auth.js.map
+//# sourceMappingURL=auth.js.map

package/dist/protocol/http/server.js

@@ -0,0 +1,111 @@
+import express from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpServer } from "../mcp.js";
+import { bearerVerifier } from "./auth.js";
+import { createWebRouter } from "./web.js";
+/** Owns the listener and request-scoped MCP transports. Disconnecting a request never cancels a task. */
+export class HttpServer {
+    app = express();
+    connections = new Set();
+    listener;
+    opening;
+    closing;
+    accepting = true;
+    constructor(options) {
+        const authorized = bearerVerifier(options.token);
+        const app = this.app;
+        app.disable("x-powered-by");
+        app.disable("etag");
+        app.use((_req, res, next) => {
+            if (!this.accepting) {
+                res.status(503).end();
+                return;
+            }
+            next();
+        });
+        if (options.settings && options.adminToken) {
+            app.use("/admin", createWebRouter(options.tasks, options.settings, options.adminToken, options.fatal, options.restart, options.instanceId));
+        }
+        app.use("/mcp", (req, res, next) => {
+            const suffix = req.socket.localPort === 80 ? "" : ":" + req.socket.localPort;
+            if (req.headers.origin !== undefined || !["127.0.0.1" + suffix, "localhost" + suffix].includes(req.headers.host ?? "")) {
+                res.status(403).end();
+                return;
+            }
+            if (!authorized(req.headers.authorization)) {
+                res.status(401).set("WWW-Authenticate", "Bearer").end();
+                return;
+            }
+            next();
+        }, express.json({ limit: "512kb" }));
+        app.post("/mcp", async (req, res) => {
+            const server = createMcpServer(options.tasks, options.fatal);
+            const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+            let closed;
+            const close = () => closed ??= (async () => {
+                try {
+                    await transport.close();
+                }
+                finally {
+                    try {
+                        await server.close();
+                    }
+                    finally {
+                        this.connections.delete(close);
+                    }
+                }
+            })();
+            this.connections.add(close);
+            res.once("close", () => { void close().catch(() => { }); });
+            try {
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch {
+                if (!res.headersSent)
+                    res.status(500).json({ error: "MCP request failed" });
+                await close();
+            }
+        });
+        app.all("/mcp", (_req, res) => { res.status(405).set("Allow", "POST").end(); });
+        app.use((_req, res) => { res.status(404).end(); });
+        app.use(((error, _req, res, _next) => {
+            res.status(error.status === 413 ? 413 : 400).json({ error: "Invalid request body" });
+        }));
+    }
+    async listen(port) {
+        if (this.closing || this.listener)
+            throw new Error("HTTP server closed or already listening");
+        const server = this.app.listen(port, "127.0.0.1");
+        this.listener = server;
+        this.opening = new Promise((done, reject) => {
+            server.once("listening", done);
+            server.once("error", reject);
+        });
+        await this.opening;
+        if (this.closing) {
+            await this.closing;
+            throw new Error("Startup stopped");
+        }
+        const address = this.listener.address();
+        return "http://127.0.0.1:" + (typeof address === "object" && address ? address.port : port);
+    }
+    stopAccepting() { this.accepting = false; }
+    closeConnections() { this.listener?.closeAllConnections(); }
+    close(drain = false) {
+        this.stopAccepting();
+        return this.closing ??= (async () => {
+            await this.opening?.catch(() => { });
+            await Promise.allSettled([...this.connections].map(close => close()));
+            if (this.listener) {
+                if (drain)
+                    this.listener.close(); // Keep the authenticated restart response alive.
+                else {
+                    this.listener.closeAllConnections();
+                    await new Promise(done => this.listener.close(() => done()));
+                }
+            }
+        })();
+    }
+}
+//# sourceMappingURL=server.js.map