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

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

package/dist/{web.js → protocol/http/web.js}

@@ -1,9 +1,11 @@
 import express from "express";
 import { fileURLToPath } from "node:url";
-import { bearerVerifier } from "./http-auth.js";
-import { SettingsError } from "./settings.js";
-import { StorageError } from "./task-storage.js";
-import { taskIdSchema, taskListSchema, taskRunListSchema, taskUpdateSchema } from "./task-contract.js";
+import { bearerVerifier } from "./auth.js";
+import { SettingsError } from "../../configuration/settings.js";
+import { previewSettings } from "../../configuration/management.js";
+import { StorageError } from "../../shared/errors.js";
+import { parseSettings, settingsConfigSchema, settingsChangeSchema, credentialUpdateSchema } from "../settings-contract.js";
+import { taskIdSchema, taskListSchema, taskRunListSchema, taskUpdateSchema } from "../task-contract.js";
 function query(schema, request) {
     const value = { ...request.query };
     for (const key of ["after", "limit"]) {
@@ -53,7 +55,7 @@ export function createWebRouter(tasks, settings, token, fatal, restart, instance
         next();
     });
     const assets = new Map(["index.html", "app.js", "api.js", "dom.js", "tasks-view.js", "settings-view.js", "style.css"]
-        .map(name => [name === "index.html" ? "/" : "/" + name, fileURLToPath(new URL("./web/" + name, import.meta.url))]));
+        .map(name => [name === "index.html" ? "/" : "/" + name, fileURLToPath(new URL("../../web/" + name, import.meta.url))]));
     router.get(["/", ...[...assets.keys()].filter(path => path !== "/")], (req, res) => {
         res.sendFile(assets.get(req.path), { lastModified: false, cacheControl: false, acceptRanges: false }, error => { if (error && !res.headersSent)
             res.status(404).end(); });
@@ -75,27 +77,26 @@ export function createWebRouter(tasks, settings, token, fatal, restart, instance
                 res.status(400).json({ error: "Request rejected; check inputs and refresh the current state" });
         }
     };
-    router.get("/api/status", respond(() => ({ ...tasks.status(), settings: settings.status(), instanceId })));
+    router.get("/api/status", respond(() => ({ ...tasks.supervisor.status(), settings: settings.status(), instanceId })));
     router.get("/api/tasks", respond(req => {
-        const input = query(taskListSchema, req), page = tasks.list(input.after, input.limit);
+        const input = query(taskListSchema, req), page = tasks.definitions.list(input.after, input.limit);
         return { ...page, items: page.items.map(task => ({ id: task.id, name: task.input.name, status: task.status, nextAt: task.nextAt, schedule: task.input.schedule })) };
     }));
-    router.get("/api/tasks/:id", respond(req => tasks.get(taskIdSchema.parse(req.params).id)));
+    router.get("/api/tasks/:id", respond(req => tasks.definitions.get(taskIdSchema.parse(req.params).id)));
     router.get("/api/runs", respond(req => {
-        const input = query(taskRunListSchema, req), page = tasks.runs(input.taskId, input.after, input.limit);
+        const input = query(taskRunListSchema, req), page = tasks.runs.list(input.taskId, input.after, input.limit);
         return { ...page, items: page.items.map(run => ({ id: run.id, taskId: run.taskId, status: run.status,
                 createdAt: run.createdAt, finishedAt: run.finishedAt, error: run.error,
                 accepted: run.nodes.filter(node => node.status === "succeeded").length, total: run.nodes.length })) };
     }));
-    router.get("/api/runs/:id", respond(req => tasks.run(taskIdSchema.parse(req.params).id)));
-    router.post("/api/task-update", respond(req => tasks.update(taskUpdateSchema.parse(req.body))));
+    router.get("/api/runs/:id", respond(req => tasks.runs.get(taskIdSchema.parse(req.params).id)));
+    router.post("/api/task-update", respond(req => tasks.definitions.update(taskUpdateSchema.parse(req.body))));
     router.get("/api/settings", respond(() => settings.get()));
-    router.post("/api/settings/validate", respond(req => {
-        const config = settings.validate(req.body);
-        return { config, affectedTasks: tasks.executorImpact(config.executors) };
-    }));
-    router.post("/api/settings/config", respond(req => settings.saveConfig(req.body)));
-    router.post("/api/settings/credential", respond(req => settings.saveCredential(req.body)));
+    router.get("/api/settings/diff", respond(() => settings.diff()));
+    router.post("/api/settings/prepare", respond(req => settings.prepareChange(parseSettings(settingsChangeSchema, req.body))));
+    router.post("/api/settings/validate", respond(req => previewSettings(settings, tasks.definitions, parseSettings(settingsConfigSchema, req.body))));
+    router.post("/api/settings/config", respond(req => settings.saveConfig(parseSettings(settingsConfigSchema, req.body))));
+    router.post("/api/settings/credential", respond(req => settings.saveCredential(parseSettings(credentialUpdateSchema, req.body))));
     router.post("/api/restart", async (req, res) => {
         if (!req.body || Array.isArray(req.body) || typeof req.body !== "object" || Object.keys(req.body).length) {
             res.status(400).json({ error: "Expected an empty request" });

package/dist/{mcp.js → protocol/mcp.js}

@@ -1,9 +1,9 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
-import { errorText } from "./model.js";
-import { StorageError } from "./task-storage.js";
+import { errorText } from "../shared/errors.js";
+import { StorageError } from "../shared/errors.js";
 import { replySchema, taskSchema, taskUpdateSchema, taskIdSchema, taskListSchema, taskRunListSchema } from "./task-contract.js";
-import { version } from "./version.js";
+import { version } from "../infrastructure/version.js";
 export function createMcpServer(service, fatal) {
     const server = new McpServer({ name: "agent-task", version });
     function register(name, description, inputSchema, execute, readOnly = true) {
@@ -25,16 +25,16 @@ export function createMcpServer(service, fatal) {
                 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);
+    register("service_status", "Service health and active node run IDs. MCP disconnection does not cancel tasks.", z.object({}).strict(), () => service.supervisor.status());
+    register("executor_list", "Registered local ACP execution profiles and authorization settings. Approval filtering is not a sandbox.", z.object({}).strict(), () => service.executors.list());
+    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.definitions.create(input), false);
+    register("task_list", "List persisted task definitions.", taskListSchema, input => service.definitions.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.definitions.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.definitions.update(input), false);
+    register("task_run_list", "List independent task runs with node progress and blocking reasons.", taskRunListSchema, input => service.runs.list(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.runs.get(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.supervisor.reply(input), false);
+    register("task_run_cancel", "Stop this task run; external effects are not rolled back.", taskIdSchema, input => service.supervisor.cancel(input.id), false);
     return server;
 }
 //# sourceMappingURL=mcp.js.map

package/dist/protocol/services.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=services.js.map