@realqiyan/agent-task 0.0.0-stage → 0.0.1-rc.2

package/dist/environment.js

@@ -0,0 +1,36 @@
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./config.js";
+import { readPrivateText } from "./private-files.js";
+export function parseEnvironment(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        throw new Error("Invalid environment file JSON");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value) || Object.entries(value).some(([key, item]) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) || ["__proto__", "constructor", "prototype"].includes(key) ||
+        typeof item !== "string" || item.includes("\0")))
+        throw new Error("Invalid environment file");
+    return value;
+}
+export function readEnvironment(path) {
+    return parseEnvironment(readPrivateText(path));
+}
+/** Credential names and values must stay separate, including historical token aliases. */
+export function validateServiceEnvironment(config, environment) {
+    const token = environment[config.tokenEnv], adminToken = environment[ADMIN_TOKEN_ENV];
+    if (!token || !/^[!-~]{32,256}$/.test(token))
+        throw new Error("A private service token of 32–256 visible ASCII characters is required");
+    if (adminToken !== undefined && (!/^[!-~]{32,256}$/.test(adminToken) || adminToken === token))
+        throw new Error("Invalid or reused administrator token");
+    const credential = config.coordinator ? environment[coordinatorCredentialEnv(config.coordinator)] : undefined;
+    if (credential && (credential === token || credential === adminToken))
+        throw new Error("Model credentials must be distinct from service and administrator tokens");
+    return { token, adminToken };
+}
+/** Explicit file mode never falls back to inherited shell credentials. */
+export function baseEnvironment(source) {
+    return Object.fromEntries(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR"]
+        .filter(key => source[key] !== undefined).map(key => [key, source[key]]));
+}
+//# sourceMappingURL=environment.js.map

package/dist/executor-runtime.js

@@ -0,0 +1,37 @@
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./config.js";
+const commands = {
+    pi: { command: "pi-acp", args: [] },
+    codex: { command: "codex-acp", args: [] },
+    claude: { command: "claude-agent-acp", args: [] },
+    opencode: { command: "opencode", args: ["acp"] },
+};
+/** Fixed ACP adapters, resolved in the OS user's native PATH. Never a shell command. */
+export function executorCommand(type, environment) {
+    const find = (name) => {
+        for (const directory of (environment.PATH ?? "").split(delimiter).filter(isAbsolute)) {
+            try {
+                const path = realpathSync(join(directory, name));
+                accessSync(path, constants.X_OK);
+                if (statSync(path).isFile())
+                    return path;
+            }
+            catch { /* Try the next native PATH entry. */ }
+        }
+        throw new Error("Missing ACP dependency on native PATH: " + name);
+    };
+    const entry = commands[type];
+    if (type === "pi")
+        find("pi");
+    return { command: find(entry.command), args: [...entry.args] };
+}
+/** Private service inputs never enter workers, even through an alias with the same value. */
+export function executorEnvironment(native, privateValues, config) {
+    const blocked = new Set([...Object.keys(privateValues), config.tokenEnv, ADMIN_TOKEN_ENV,
+        ...(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : [])]);
+    const secrets = new Set([...Object.values(privateValues), ...[...blocked].map(key => native[key])].filter(Boolean));
+    return Object.fromEntries(Object.entries(native).filter(([key, value]) => value !== undefined && !blocked.has(key) && !secrets.has(value) &&
+        !/^(AGENT_TASK_|NODE_|LD_|DYLD_)/.test(key) && key !== "PI_ACP_PI_COMMAND"));
+}
+//# sourceMappingURL=executor-runtime.js.map

package/dist/http-auth.js

@@ -0,0 +1,9 @@
+import { timingSafeEqual } from "node:crypto";
+export function bearerVerifier(token) {
+    const expected = Buffer.from("Bearer " + token);
+    return header => {
+        const actual = Buffer.from(header ?? "");
+        return actual.length === expected.length && timingSafeEqual(actual, expected);
+    };
+}
+//# sourceMappingURL=http-auth.js.map

package/dist/human-input.js

@@ -0,0 +1,62 @@
+import { randomUUID } from "node:crypto";
+import { iso } from "./model.js";
+/** Human facts are persisted business state, not executor permission or retry authorization. */
+export function askInput(run, request, seconds, now) {
+    if (run.status !== "running")
+        throw new Error("Task run is not running");
+    if (run.nodes.some(node => node.status === "running"))
+        throw new Error("Wait for all ACP turns before asking for input");
+    if (request.nodeId && !run.nodes.some(node => node.definition.id === request.nodeId))
+        throw new Error("Unknown question node");
+    if (run.questions.length >= 20)
+        throw new Error("Question limit reached");
+    const sessions = run.nodes.filter(node => node.status === "awaiting_review");
+    const question = { ...request, id: randomUUID(), createdAt: iso(now), expiresAt: iso(now + seconds * 1000),
+        sessionExpiresAt: sessions.length ? iso(Math.min(now + 300_000, ...sessions.map(node => Date.parse(node.startedAt) + node.definition.maxRunSeconds * 1000))) : null, reply: null };
+    run.questions.push(question);
+    run.status = "waiting_input";
+    return question;
+}
+export function waitingFailure(run, now) {
+    if (run.status !== "waiting_input")
+        return;
+    const question = run.questions.at(-1);
+    if (question.sessionExpiresAt && now >= Date.parse(question.sessionExpiresAt)) {
+        return { status: "interrupted", reason: "ACP session retention expired while waiting; reconcile external effects before any new work" };
+    }
+    if (now >= Date.parse(question.expiresAt))
+        return { status: "timed_out", reason: "Human input deadline reached" };
+}
+/** Exact retries return their receipt, even after completion/cancellation; they never reactivate a run. */
+export function applyReply(run, input, now) {
+    const question = run.questions.find(value => value.id === input.questionId);
+    if (!question)
+        throw new Error("Unknown question");
+    const used = run.questions.find(value => value.reply?.requestKey === input.requestKey);
+    if (used) {
+        if (used.id !== question.id || used.reply.answer !== input.answer)
+            throw new Error("Reply requestKey already used with different parameters");
+        return false;
+    }
+    if (question.reply || run.questions.at(-1)?.id !== question.id)
+        throw new Error("Question already answered or stale");
+    if (run.status !== "waiting_input")
+        throw new Error("Task run is not waiting for input: " + run.status);
+    const failure = waitingFailure(run, now);
+    if (failure)
+        throw new Error(failure.reason);
+    question.reply = { requestKey: input.requestKey, answer: input.answer, receivedAt: iso(now) };
+    run.waitedMs += Math.max(0, now - Date.parse(question.createdAt));
+    run.status = "running";
+    return true;
+}
+export function coordinatorInput(run) {
+    const question = run.questions.findLast(value => value.reply !== null);
+    if (!question)
+        return { requestId: "run:" + run.id, content: "Advance this task run using its caller-defined DAG. Start by reading inspect_run." };
+    return { requestId: "reply:" + question.id,
+        content: "Human facts for the existing task run. Read inspect_run; preserve the committed plan and accepted deliveries. This reply grants no permissions or authorization to retry uncertain effects.\n" +
+            JSON.stringify({ questionId: question.id, nodeId: question.nodeId, question: question.question,
+                completedWork: question.completedWork, answer: question.reply.answer }) };
+}
+//# sourceMappingURL=human-input.js.map

package/dist/launcher.js

@@ -0,0 +1,238 @@
+import { fork } from "node:child_process";
+import { createServer, request } from "node:http";
+import { appendFileSync, chmodSync, closeSync, constants, existsSync, fstatSync, lstatSync, openSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { acquireLauncherLock } from "./lock.js";
+import { prepareStartup, startupPaths } from "./startup.js";
+import { readEnvironment } from "./environment.js";
+import { loadConfig } from "./config.js";
+function message(child, type, timeout = 30_000) {
+    return new Promise((resolve, reject) => {
+        const cleanup = () => { clearTimeout(timer); child.off("message", receive); child.off("exit", exit); child.off("error", fail); };
+        const fail = () => { cleanup(); reject(new Error("Service process failed before " + type)); };
+        const exit = () => fail();
+        const receive = (value) => { if (value.type === type) {
+            cleanup();
+            resolve(value);
+        } };
+        const timer = setTimeout(() => { cleanup(); reject(new Error("Service timed out before " + type)); }, timeout);
+        child.on("message", receive);
+        child.once("exit", exit);
+        child.once("error", fail);
+    });
+}
+async function stop(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    const closed = new Promise(resolve => child.once("close", () => resolve()));
+    child.kill("SIGTERM");
+    const timer = setTimeout(() => child.kill("SIGKILL"), 12_000);
+    try {
+        await closed;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function health(ready, token) {
+    const response = await fetch(ready.url, {
+        method: "POST", headers: { Authorization: "Bearer " + token, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "service_status", arguments: {} } }),
+        signal: AbortSignal.timeout(5000),
+    });
+    const body = await response.json();
+    if (!response.ok || !body.result?.structuredContent?.data?.running)
+        throw new Error("Authenticated health check failed");
+}
+function removeSocket(path) {
+    if (!existsSync(path))
+        return;
+    const stat = lstatSync(path);
+    if (!stat.isSocket() || stat.uid !== process.getuid())
+        throw new Error("Refusing to remove an unowned control socket path");
+    unlinkSync(path);
+}
+function logFile(path) {
+    const fd = openSync(path, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.uid !== process.getuid() || (stat.mode & 0o077)) {
+        closeSync(fd);
+        throw new Error("Invalid private log file");
+    }
+    return fd;
+}
+/** Stable owner for foreground and service managers. Only explicit requests restart a child. */
+export async function launch(home, nativeEnvironment) {
+    process.umask(0o077);
+    startupPaths(home); // Also checks private ownership of the locator.
+    const unlock = acquireLauncherLock(home);
+    const socket = join(home, "control.sock"), children = new Set();
+    let current, ready, restarting = true, closing = false;
+    let release;
+    const finished = new Promise(resolve => { release = resolve; });
+    const control = createServer(async (req, res) => {
+        try {
+            if (req.method !== "POST" || !["/status", "/restart"].includes(req.url ?? "")) {
+                res.writeHead(404).end();
+                return;
+            }
+            const result = req.url === "/restart" ? await restart() : await status();
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(result));
+        }
+        catch {
+            res.writeHead(503).end(JSON.stringify({ error: "Service unavailable; inspect private logs and startup files" }));
+        }
+    });
+    const shutdown = async () => {
+        if (closing)
+            return;
+        closing = true;
+        control.close();
+        control.closeAllConnections();
+        await Promise.all([...children].map(stop));
+        try {
+            removeSocket(socket);
+        }
+        finally {
+            unlock();
+            release();
+        }
+    };
+    const signal = () => { void shutdown(); };
+    process.on("SIGINT", signal);
+    process.on("SIGTERM", signal);
+    const start = async () => {
+        const inputs = await prepareStartup(home);
+        if (closing)
+            throw new Error("Launcher is closing");
+        const log = logFile(join(inputs.dataDir, "service.log"));
+        const child = fork(fileURLToPath(new URL("./main.js", import.meta.url)), ["--config", inputs.configPath, "--environment", inputs.environmentPath], {
+            env: { ...nativeEnvironment, AGENT_TASK_INSTANCE_ID: randomUUID() }, execArgv: [], stdio: ["ignore", "pipe", "pipe", "ipc"],
+        });
+        children.add(child);
+        const output = (chunk) => { appendFileSync(log, chunk); process.stdout.write(chunk); };
+        child.stdout.on("data", output);
+        child.stderr.on("data", output);
+        child.once("close", () => {
+            closeSync(log);
+            children.delete(child);
+            if (current === child && !restarting && !closing) {
+                ready = undefined;
+                process.exitCode = 1;
+                void shutdown();
+            }
+        });
+        child.on("message", (value) => {
+            if (value.type !== "restart")
+                return;
+            if (child !== current || restarting || closing) {
+                child.send({ type: "restarted", error: "Restart already in progress or unavailable" }, () => { });
+                return;
+            }
+            void restart(child).then(value => {
+                if (child.connected)
+                    child.send({ type: "restarted", ready: value }, () => { });
+            }, () => {
+                if (child.connected)
+                    child.send({ type: "restarted", error: "Restart failed; inspect private logs and use CLI restart after correcting startup files" }, () => { });
+            });
+        });
+        try {
+            const value = (await message(child, "ready")).ready;
+            await health(value, inputs.environment[inputs.config.tokenEnv]);
+            current = child;
+            ready = value;
+            return value;
+        }
+        catch (error) {
+            await stop(child);
+            throw error;
+        }
+    };
+    const status = async () => {
+        if (!ready || restarting || closing)
+            throw new Error("Service unavailable");
+        const paths = startupPaths(home), config = loadConfig(paths.configPath), env = readEnvironment(paths.environmentPath);
+        await health(ready, env[config.tokenEnv]);
+        return ready;
+    };
+    const restart = async (requester) => {
+        if (restarting || closing)
+            throw new Error("Restart already in progress or closed");
+        restarting = true;
+        const old = current;
+        current = undefined;
+        ready = undefined;
+        try {
+            if (old) {
+                const drained = message(old, "drained");
+                old.send({ type: "drain" });
+                try {
+                    await drained;
+                }
+                catch (error) {
+                    await stop(old);
+                    throw error;
+                }
+                // Keep only the authenticated Web response alive until the new process is verified.
+                if (old !== requester)
+                    await stop(old);
+            }
+            const value = await start();
+            return value;
+        }
+        finally {
+            restarting = false;
+            if (requester) {
+                const timer = setTimeout(() => { void stop(requester); }, 5000);
+                requester.once("close", () => clearTimeout(timer));
+            }
+        }
+    };
+    try {
+        removeSocket(socket); // Stale socket only, under exclusive launcher ownership.
+        await new Promise((resolve, reject) => { control.once("error", reject); control.listen(socket, resolve); });
+        chmodSync(socket, 0o600);
+        await start();
+        restarting = false;
+        await finished;
+    }
+    finally {
+        await shutdown();
+        process.off("SIGINT", signal);
+        process.off("SIGTERM", signal);
+    }
+}
+/** 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=launcher.js.map

package/dist/lock.js

@@ -0,0 +1,43 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+/** The stable installation lock prevents two launchers or uninstall during a directory switch. */
+export function acquireLauncherLock(home) {
+    const db = new DatabaseSync(join(home, "launcher-lock.sqlite"));
+    try {
+        db.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE");
+    }
+    catch {
+        db.close();
+        throw new Error("Another launcher owns this installation");
+    }
+    let released = false;
+    return () => { if (!released) {
+        db.close();
+        released = true;
+    } };
+}
+/** A dedicated SQLite transaction owns an OS lock until close or process death.
+ * Local filesystems only. Never unlink this file: that would create a second lock identity.
+ */
+export async function acquireLock(directory) {
+    if (!["linux", "darwin"].includes(process.platform))
+        throw new Error("Supported platforms: Linux and macOS");
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(join(directory, "service-lock.sqlite"));
+    try {
+        db.exec("PRAGMA busy_timeout=0; PRAGMA journal_mode=DELETE; BEGIN EXCLUSIVE");
+    }
+    catch (error) {
+        db.close();
+        throw new Error("State directory is locked or its filesystem does not support SQLite locking", { cause: error });
+    }
+    let released = false;
+    return async () => {
+        if (released)
+            return;
+        db.close();
+        released = true;
+    };
+}
+//# sourceMappingURL=lock.js.map

package/dist/main.js

@@ -0,0 +1,175 @@
+import express from "express";
+import { resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { loadConfig } from "./config.js";
+import { baseEnvironment, readEnvironment, validateServiceEnvironment } from "./environment.js";
+import { bearerVerifier } from "./http-auth.js";
+import { Settings } from "./settings.js";
+import { createWebRouter } from "./web.js";
+import { acquireLock } from "./lock.js";
+import { createMcpServer } from "./mcp.js";
+import { errorText } from "./model.js";
+import { TaskStore } from "./task-storage.js";
+import { Tasks } from "./tasks.js";
+import { Results } from "./results.js";
+import { createExecution } from "./node-execution.js";
+import { executorEnvironment } from "./executor-runtime.js";
+import { createCoordinator } from "./coordinator.js";
+process.umask(0o077);
+const args = process.argv.slice(2);
+if (args[0] !== "--config" || args.length !== 4 || args[2] !== "--environment") {
+    console.error("Internal runtime requires --config PATH --environment PATH; use agent-task start");
+    process.exit(2);
+}
+const configPath = resolve(args[1]), environmentPath = resolve(args[3]);
+const native = { ...process.env }, base = baseEnvironment(native);
+const environment = readEnvironment(environmentPath);
+const instanceId = process.env.AGENT_TASK_INSTANCE_ID ?? randomUUID();
+for (const key of Object.keys(process.env))
+    delete process.env[key];
+Object.assign(process.env, base, environment);
+const config = loadConfig(configPath);
+const { token, adminToken } = validateServiceEnvironment(config, environment);
+const authorized = bearerVerifier(token);
+let http;
+let tasks, taskStore, settings;
+let release;
+let shutting;
+const connections = new Set();
+function shutdown(code, drain = false) {
+    process.exitCode = Math.max(process.exitCode ? Number(process.exitCode) : 0, code);
+    return shutting ??= (async () => {
+        settings?.close();
+        try {
+            await tasks?.close();
+        }
+        catch (error) {
+            console.error(errorText(error));
+            process.exitCode = 1;
+        }
+        for (const close of connections)
+            await close().catch(() => { });
+        if (http) {
+            if (drain)
+                http.close(); // Release the listener, but retain the in-flight Web restart response.
+            else {
+                http.closeAllConnections();
+                await new Promise(done => http.close(() => done()));
+            }
+        }
+        taskStore?.close();
+        await release?.();
+    })().catch(error => { console.error(errorText(error)); process.exitCode = 1; });
+}
+const fatal = (error) => { console.error(errorText(error)); void shutdown(1).finally(() => { if (process.connected)
+    process.disconnect(); }); };
+let restartPending = false;
+const restart = async () => {
+    if (!process.connected || restartPending || shutting || settings?.status().writeBlocked)
+        throw new Error("Restart unavailable");
+    restartPending = true;
+    return new Promise((resolve, reject) => {
+        process.once("message", function receive(value) {
+            if (value.type !== "restarted") {
+                process.once("message", receive);
+                return;
+            }
+            // The HTTP adapter finishes the authenticated response before this child exits.
+            setTimeout(() => { if (process.connected)
+                process.disconnect(); http?.closeAllConnections(); }, 200);
+            if (value.error)
+                reject(new Error(value.error));
+            else
+                resolve(value.ready);
+        });
+        process.send({ type: "restart" });
+    });
+};
+process.on("message", (value) => {
+    if (value.type === "drain")
+        void shutdown(0, true).then(() => {
+            if (process.exitCode) {
+                if (process.connected)
+                    process.disconnect();
+            }
+            else
+                process.send?.({ type: "drained" });
+        });
+});
+const stop = () => { void shutdown(0).finally(() => { http?.closeAllConnections(); if (process.connected)
+    process.disconnect(); }); };
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+process.once("disconnect", stop);
+try {
+    release = await acquireLock(config.dataDir);
+    taskStore = new TaskStore(config.dataDir);
+    tasks = new Tasks(taskStore, config.executors, new Results(config.dataDir), createExecution(executorEnvironment(native, environment, config)), config.coordinator ? createCoordinator(config.dataDir, config.coordinator) : undefined, fatal);
+    const app = express();
+    app.disable("x-powered-by");
+    app.disable("etag");
+    app.use((_req, res, next) => {
+        if (shutting) {
+            res.status(503).end();
+            return;
+        }
+        next();
+    });
+    if (adminToken) {
+        settings = new Settings(configPath, environmentPath, config, base, process.env);
+        app.use("/admin", createWebRouter(tasks, settings, adminToken, fatal, restart, 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(tasks, fatal);
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        const close = async () => { connections.delete(close); await transport.close(); await server.close(); };
+        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" });
+    }));
+    http = await new Promise((done, reject) => {
+        const listening = app.listen(config.port, "127.0.0.1", () => done(listening));
+        listening.once("error", reject);
+    });
+    if (shutting) {
+        http.closeAllConnections();
+        http.close();
+        throw new Error("Startup stopped");
+    }
+    tasks.start();
+    const address = http.address();
+    const origin = "http://127.0.0.1:" + (typeof address === "object" && address ? address.port : config.port);
+    const ready = { instanceId, pid: process.pid, url: origin + "/mcp", consoleUrl: settings ? origin + "/admin/" : null };
+    console.log(JSON.stringify({ event: "ready", ...ready }));
+    process.send?.({ type: "ready", ready });
+}
+catch (error) {
+    fatal(error);
+}
+//# sourceMappingURL=main.js.map

package/dist/mcp.js

@@ -0,0 +1,40 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { errorText } from "./model.js";
+import { StorageError } from "./task-storage.js";
+import { replySchema, taskSchema, taskUpdateSchema, taskIdSchema, taskListSchema, taskRunListSchema } from "./task-contract.js";
+import { version } from "./version.js";
+export function createMcpServer(service, fatal) {
+    const server = new McpServer({ name: "agent-task", version });
+    function register(name, description, inputSchema, execute, readOnly = true) {
+        const outputSchema = z.object({ ok: z.boolean(), data: z.unknown().optional(), error: z.string().optional() });
+        server.registerTool(name, {
+            description, inputSchema, outputSchema,
+            annotations: { readOnlyHint: readOnly, destructiveHint: !readOnly, idempotentHint: readOnly, openWorldHint: !readOnly },
+        }, async (input) => {
+            let value;
+            try {
+                value = { ok: true, data: execute(input) };
+            }
+            catch (error) {
+                if (error instanceof StorageError)
+                    fatal(error);
+                value = { ok: false, error: errorText(error) };
+            }
+            return { content: [{ type: "text", text: JSON.stringify(value) }], structuredContent: value,
+                isError: !value.ok };
+        });
+    }
+    register("service_status", "Service health and active node run IDs. MCP disconnection does not cancel tasks.", z.object({}).strict(), () => service.status());
+    register("executor_list", "Registered local ACP execution profiles and authorization settings. Approval filtering is not a sandbox.", z.object({}).strict(), () => service.listExecutors());
+    register("task_create", "Create a task with a caller-defined DAG in nodes. Each node selects an administrator-registered ACP executorId. The coordinator advances this fixed DAG, reviews deliveries and requests missing user facts; it does not plan new nodes. Optional workspace selects an existing absolute directory; otherwise each executor uses its registered cwd. Path checks do not grant permissions; no uncertain-effect retries.", taskSchema, input => service.create(input), false);
+    register("task_list", "List persisted task definitions.", taskListSchema, input => service.list(input.after, input.limit));
+    register("task_get", "Get task goal, caller-defined DAG and assigned executor profiles, canonical workspace (null means executor cwd defaults), budgets and schedule.", taskIdSchema, input => service.get(input.id));
+    register("task_update", "Pause, resume or cancel future triggers only; resume never catches up. To change a task, cancel it and create a new task. Use task_run_cancel to stop an active run; cancellation does not roll back external effects.", taskUpdateSchema, input => service.update(input), false);
+    register("task_run_list", "List independent task runs with node progress and blocking reasons.", taskRunListSchema, input => service.runs(input.taskId, input.after, input.limit));
+    register("task_run_get", "Get the committed plan, selected node workspaces, ACP turns, accepted deliveries, blocking questions and errors for one task run.", taskIdSchema, input => service.run(input.id));
+    register("task_run_reply", "Answer a persisted question on the same task run. Deduplicated by requestKey; no permission escalation or uncertain-effect replay.", replySchema, input => service.reply(input), false);
+    register("task_run_cancel", "Stop this task run; external effects are not rolled back.", taskIdSchema, input => service.cancel(input.id), false);
+    return server;
+}
+//# sourceMappingURL=mcp.js.map