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

package/README.md

@@ -8,8 +8,9 @@
 
 | 目的 | 入口 |
 | --- | --- |
-| 安装、认证、后台运行、卸载 | [部署说明](docs/deployment.md) |
-| 本机控制台、配置保存与手动重启 | [控制台说明](docs/web-console.md) |
+| 安装、配置、运行 | [部署说明](docs/deployment.md) |
+| 本机控制台、配置保存与 Web/CLI 重启 | [控制台说明](docs/web-console.md) |
+| 命令行配置、凭据和任务管理 | [CLI 说明](docs/cli.md) |
 | 理解产品目标和架构选择 | [总体方案](docs/design-proposal.md) |
 | 查找实现与对应测试 | [代码导航](docs/technical-design.md) |
 | 查询测试命令、真实验收及缺口 | [验证说明](docs/validation.md) |
@@ -20,7 +21,7 @@
 
 ## 使用入口
 
-Linux/macOS，Node.js **22.19+**。安装包自带运行产物，无需克隆或编译。发布目标为 `0.0.1-rc.1`，使用 `latest`；实际发布与平台验收状态见[发布证据](docs/validation.md#npm-发布候选验证)。
+Linux/macOS，Node.js **22.19+**。安装包自带运行产物，无需克隆或编译。`latest` 指向的已发布版本及平台验收范围见[发布证据](docs/validation.md#npm-发布候选验证)。
 
 ```bash
 npm install -g @realqiyan/agent-task
@@ -28,9 +29,11 @@ agent-task setup
 agent-task start
 # 另一个终端进行带认证的健康检查：
 agent-task status
+# 应用已保存配置并确认新实例可用：
+agent-task restart
 ```
 
-npm 包名为 `@realqiyan/agent-task`，安装后的命令仍为 `agent-task`。setup 提供交互配置；启动后可使用本机 Web 控制台。先停止前台实例，再用 `agent-task service install` 安装并启动用户后台服务。安装器不会替用户登录或批准执行端；详细操作见[部署说明](docs/deployment.md)。
+npm 包名为 `@realqiyan/agent-task`，安装后的命令仍为 `agent-task`。setup 提供交互配置；启动后可使用本机 Web 控制台或 [CLI](docs/cli.md)，两端共用管理服务。安装器不会替用户登录或批准执行端；详细操作见[部署说明](docs/deployment.md)。
 
 MCP 客户端使用独立服务 token。源码开发辅助命令（凭据须安全注入环境，不写命令行）：
 
@@ -39,7 +42,7 @@ node scripts/mcp-call.mjs --list
 node scripts/mcp-call.mjs service_status
 ```
 
-任务由 `task_create` 提交固定 DAG，每个节点选择已注册执行端。具体契约见 [task-contract.ts](src/task-contract.ts)，管理工具见 [mcp.ts](src/mcp.ts)。Prompt、人工回复和工作空间选择都不授予工具权限。
+任务由 `task_create` 提交固定 DAG，每个节点选择已注册执行端。具体契约见 [task-contract.ts](src/protocol/task-contract.ts)，管理工具见 [mcp.ts](src/protocol/mcp.ts)。Prompt、人工回复和工作空间选择都不授予工具权限。
 
 ## 许可证
 

package/bin/agent-task.mjs

@@ -4,17 +4,17 @@ import { readFileSync } from "node:fs";
 const help = `Usage: agent-task <command>
   setup [options]           Interactive configuration (setup --help for flags)
   start [--home PATH]        Foreground service using the private installation
-  start --config PATH --environment PATH
-                            Foreground service with explicit private files
-  status [--home PATH]       Authenticated MCP health check; no token printed
-  service install [--home PATH]
-                            Install/start systemd user service or LaunchAgent
-  service remove [--home PATH]
-                            Stop/remove only the owned service
-  uninstall [--home PATH]    Remove service and owned executor components;
-                            preserve configuration, credentials and task data
+  restart [--home PATH]      Restart runtime; verify readiness
+  status [--home PATH]       Health, active work and pending configuration
+  config                    Show, edit, validate and apply configuration
+  executor                  Manage registrations and unattended authorization
+  coordinator               Configure the coordination model
+  credential                List, replace or delete private credentials
+  task                      Inspect tasks and control future triggers
+  run                       Inspect run history and deliveries
+  <command> --help           Command usage; management supports --json
   --version | --help
-Node.js 22.19+; Linux or macOS. Setup never grants executor permissions.`;
+Node.js 22.19+; Linux or macOS.`;
 try {
   const [major, minor] = process.versions.node.split(".").map(Number);
   if (major < 22 || (major === 22 && minor < 19)) throw new Error("Node.js 22.19+ is required");
@@ -23,44 +23,26 @@ try {
     console.log(help);
   } else if (command === "--version") {
     console.log(JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version);
-  } else if (command === "setup" || command === "uninstall") {
+  } else if (command === "setup") {
     process.argv = [process.execPath, command, ...args];
     await import(`../scripts/${command}.mjs`);
-  } else if (command === "start" && args[0] === "--config") {
-    if (args.length !== 4 || args[2] !== "--environment") throw new Error("Use start --config PATH --environment PATH");
-    process.argv = [process.execPath, "agent-task", ...args];
-    await import("../dist/main.js");
   } else {
     const lib = await import("../scripts/install-lib.mjs");
-    const action = command === "service" ? args.shift() : undefined;
-    if (!["start", "status", "service"].includes(command) || (command === "service" && !["install", "remove"].includes(action))) throw new Error(help);
-    const options = lib.argumentsFor(args);
-    if (Object.keys(options).some(key => key !== "home")) throw new Error("Only --home is accepted here");
-    const root = lib.installRoot(options);
-    if (action === "install") {
-      process.argv = [process.execPath, "setup", "--home", root, "--service"];
-      await import("../scripts/setup.mjs");
-    } else if (action === "remove") {
-      lib.readManifest(root);
-      const unlock = lib.operationLock(root);
-      try {
-        const manifest = lib.readManifest(root);
-        lib.deactivate(manifest);
-        manifest.serviceInstalled = false;
-        lib.saveManifest(root, manifest);
-        console.log("Owned service removed; configuration, credentials, components and data preserved.");
-      } finally { unlock(); }
-    } else if (command === "start") {
-      process.argv = [process.execPath, "service-runner", root];
-      await import("../scripts/service-runner.mjs");
+    if (command === "start") {
+      if (args.includes("--help")) { console.log("Usage: agent-task start [--home ABSOLUTE_DIR]"); }
+      else {
+        const options = lib.argumentsFor(args);
+        if (Object.keys(options).some(key => key !== "home")) throw new Error("Only --home is accepted here");
+        const root = lib.installRoot(options);
+        process.argv = [process.execPath, "service-runner", root];
+        await import("../scripts/service-runner.mjs");
+      }
     } else {
-      const manifest = lib.readManifest(root);
-      if (manifest.phase !== "ready") throw new Error("Installation is not ready");
-      await lib.checkHealth(lib.json(root + "/config.json"), lib.runtimeEnv(manifest));
-      console.log("Authenticated MCP health check passed.");
+      const { runCli } = await import("../dist/protocol/cli/commands.js");
+      await runCli(command, args, home => lib.installRoot({ home }));
     }
   }
 } catch (error) {
-  console.error(error.message);
+  console.error(process.argv.includes("--json") ? JSON.stringify({ error: error.message }) : error.message);
   process.exitCode = 1;
 }

package/dist/application/launcher.js

@@ -0,0 +1,215 @@
+import { fork } from "node:child_process";
+import { createServer } 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 "../infrastructure/lock.js";
+import { prepareStartup } from "./startup.js";
+import { startupPaths } from "../configuration/files.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 = { info: value, token: inputs.environment[inputs.config.tokenEnv] };
+            return value;
+        }
+        catch (error) {
+            await stop(child);
+            throw error;
+        }
+    };
+    const status = async () => {
+        if (!ready || restarting || closing)
+            throw new Error("Service unavailable");
+        // Saved inputs may need repair. Health belongs to the running instance,
+        // including the credential with which that instance actually started.
+        const running = ready;
+        await health(running.info, running.token);
+        return running.info;
+    };
+    const restart = async (requester) => {
+        if (restarting || closing)
+            throw new Error("Restart already in progress or closed");
+        restarting = true;
+        const old = current;
+        try {
+            if (old) {
+                const drained = message(old, "drained");
+                old.send({ type: "drain" });
+                let result;
+                try {
+                    result = await drained;
+                }
+                catch (error) {
+                    current = undefined;
+                    ready = undefined;
+                    await stop(old);
+                    throw error;
+                }
+                if (result.error)
+                    throw new Error(result.error);
+                current = undefined;
+                ready = undefined;
+                // 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 && requester !== current) {
+                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);
+    }
+}
+//# sourceMappingURL=launcher.js.map

package/dist/application/main.js

@@ -0,0 +1,122 @@
+import { HttpServer } from "../protocol/http/server.js";
+import { createTaskRuntime } from "./task-runtime.js";
+import { LocalSettingsFiles, configurationPaths } from "../configuration/files.js";
+import { resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { loadConfig } from "../configuration/files.js";
+import { baseEnvironment, validateServiceEnvironment } from "../configuration/environment.js";
+import { readEnvironment } from "../configuration/files.js";
+import { Settings } from "../configuration/settings.js";
+import { acquireLock } from "../infrastructure/lock.js";
+import { errorText } from "../shared/errors.js";
+import { createExecution } from "../integrations/acp/execution.js";
+import { executorEnvironment } from "../executors/environment.js";
+import { createCoordinator } from "../integrations/coordinator/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);
+let http;
+let tasks, settings;
+let release;
+let shutting;
+function shutdown(code, drain = false) {
+    process.exitCode = Math.max(process.exitCode ? Number(process.exitCode) : 0, code);
+    return shutting ??= (async () => {
+        http?.stopAccepting();
+        settings?.close();
+        try {
+            await tasks?.close();
+        }
+        catch (error) {
+            console.error(errorText(error));
+            process.exitCode = 1;
+        }
+        await http?.close(drain);
+        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)
+        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;
+            }
+            if (value.error && !shutting) {
+                restartPending = false;
+                reject(new Error(value.error));
+                return;
+            }
+            // The HTTP adapter finishes the authenticated response before this child exits.
+            setTimeout(() => { if (process.connected)
+                process.disconnect(); http?.closeConnections(); }, 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")
+        return;
+    // Both Web and CLI restarts pass this boundary before changing runtime ownership.
+    try {
+        if (settings?.status().writeBlocked)
+            throw new Error("Configuration publication is uncertain");
+    }
+    catch {
+        process.send?.({ type: "drained", error: "Restart blocked; stop and inspect private configuration files" });
+        return;
+    }
+    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?.closeConnections(); if (process.connected)
+    process.disconnect(); }); };
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);
+process.once("disconnect", stop);
+try {
+    release = await acquireLock(config.dataDir);
+    tasks = createTaskRuntime(config.dataDir, config.executors, createExecution(executorEnvironment(native, environment, config)), config.coordinator ? createCoordinator(config.dataDir, config.coordinator) : undefined, fatal);
+    if (adminToken)
+        settings = new Settings(new LocalSettingsFiles(configPath, environmentPath), configurationPaths, config, base, process.env);
+    http = new HttpServer({ tasks, settings, token, adminToken, fatal, restart, instanceId });
+    const origin = await http.listen(config.port);
+    if (shutting)
+        throw new Error("Startup stopped");
+    tasks.supervisor.start();
+    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/application/startup.js

@@ -0,0 +1,51 @@
+import { startupPaths } from "../configuration/files.js";
+import { existsSync, mkdirSync, writeFileSync, openSync, fsyncSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "../configuration/files.js";
+import { readEnvironment } from "../configuration/files.js";
+import { validateServiceEnvironment } from "../configuration/environment.js";
+import { checkDataDirectory, readPrivateText, replacePrivateText } from "../infrastructure/private-files.js";
+import { acquireLock } from "../infrastructure/lock.js";
+function prepareFile(path, text) {
+    if (existsSync(path)) {
+        if (readPrivateText(path) !== text)
+            throw new Error("Target contains different startup files; refusing to overwrite them");
+        return; // Explicitly resume an interrupted preparation, not a data repair.
+    }
+    const fd = openSync(path, "wx", 0o600);
+    try {
+        writeFileSync(fd, text);
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export async function prepareStartup(home) {
+    const current = startupPaths(home), config = loadConfig(current.configPath), environment = readEnvironment(current.environmentPath);
+    validateServiceEnvironment(config, environment);
+    checkDataDirectory(config.dataDir);
+    if (config.dataDir !== current.dataDir) {
+        mkdirSync(config.dataDir, { recursive: true, mode: 0o700 });
+        checkDataDirectory(config.dataDir);
+        const release = await acquireLock(config.dataDir);
+        try {
+            // Only next-start inputs. Never copy tasks, sessions, results, native configuration or workspaces.
+            prepareFile(join(config.dataDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+            prepareFile(join(config.dataDir, "environment.json"), JSON.stringify(environment, null, 2) + "\n");
+            const fd = openSync(config.dataDir, "r");
+            try {
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            replacePrivateText(join(home, "launch.json"), JSON.stringify({ dataDir: config.dataDir }) + "\n");
+        }
+        finally {
+            await release();
+        }
+    }
+    return { ...startupPaths(home), config, environment };
+}
+//# sourceMappingURL=startup.js.map

package/dist/application/task-runtime.js

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+import { ExecutorRegistry } from "../executors/registry.js";
+import { checkWorkspace, resolveWorkspace } from "../infrastructure/workspace.js";
+import { LocalResultFiles } from "../results/files.js";
+import { Results } from "../results/service.js";
+import { TaskDefinitions } from "../tasks/definitions.js";
+import { TaskRuns } from "../tasks/runs.js";
+import { RunSupervisor } from "../tasks/supervisor.js";
+import { TaskStore } from "../tasks/storage/store.js";
+/** Creates and owns the business store and services; callers must stop ingress before closing. */
+export function createTaskRuntime(directory, profiles, openExecution, coordinate, fatal) {
+    const store = new TaskStore(directory);
+    try {
+        const executors = new ExecutorRegistry(profiles);
+        const workspaces = { resolve: resolveWorkspace, check: checkWorkspace };
+        const results = new Results(new LocalResultFiles(join(directory, "results"), true));
+        const definitions = new TaskDefinitions(store, executors, workspaces, Boolean(coordinate));
+        const runs = new TaskRuns(store, executors, results, workspaces);
+        const supervisor = new RunSupervisor(runs, openExecution, coordinate, fatal);
+        let closing;
+        return { definitions, runs, supervisor, executors,
+            close() {
+                return closing ??= (async () => {
+                    definitions.close();
+                    const stopped = supervisor.close();
+                    runs.close();
+                    try {
+                        await stopped;
+                    }
+                    finally {
+                        store.close();
+                    }
+                })();
+            },
+        };
+    }
+    catch (error) {
+        store.close();
+        throw error;
+    }
+}
+//# sourceMappingURL=task-runtime.js.map

package/dist/configuration/contract.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { executorSchema } from "../executors/validation.js";
+import { baseEnvKeys } from "./policy.js";
+const envKey = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+const modelId = z.string().min(1).max(200);
+const coordinatorSchema = z.discriminatedUnion("provider", [
+    z.object({ provider: z.enum(["openai", "anthropic", "deepseek"]), model: modelId }).strict(),
+    z.object({
+        provider: z.literal("openai-compatible"), model: modelId,
+        api: z.enum(["openai-completions", "openai-responses"]).default("openai-completions"),
+        baseUrl: z.string().url().refine(value => {
+            const url = new URL(value);
+            return ["https:", "http:"].includes(url.protocol) && !url.username && !url.password && !url.search && !url.hash;
+        }, "baseUrl must be HTTP(S) without credentials, query or fragment"),
+        apiKeyEnv: envKey.refine(key => !baseEnvKeys.includes(key), "Credential must not use a base environment key"),
+        contextWindow: z.number().int().positive(),
+        maxTokens: z.number().int().positive(),
+        reasoning: z.boolean().default(false),
+    }).strict(),
+]).refine(value => value.provider !== "openai-compatible" || value.maxTokens <= value.contextWindow, "maxTokens must not exceed contextWindow");
+export const configSchema = z.object({
+    dataDir: z.string().min(1),
+    port: z.number().int().min(0).max(65535).default(8765),
+    tokenEnv: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).default("AGENT_TASK_TOKEN"),
+    coordinator: coordinatorSchema.optional(),
+    executors: z.array(executorSchema).max(100).default([]),
+}).strict();
+//# sourceMappingURL=contract.js.map

package/dist/configuration/environment.js

@@ -0,0 +1,32 @@
+import { ADMIN_TOKEN_ENV, coordinatorCredentialEnv } from "./policy.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;
+}
+/** 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