@realqiyan/agent-task 0.0.1-rc.2 → 0.1.0-rc.1

package/scripts/setup.mjs

@@ -1,130 +1,91 @@
 #!/usr/bin/env node
 import { existsSync, mkdirSync, realpathSync, lstatSync } from "node:fs";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
+import { join, isAbsolute } from "node:path";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
-import { argumentsFor, installRoot, packages, createFile, json, run, operationLock, readManifest, saveManifest,
-  runtimeBaseEnv, activate, inventory, verifyServiceFile, packageRoot, checkHealth } from "./install-lib.mjs";
+import { argumentsFor, installRoot, createFile, json, operationLock, readManifest, saveManifest, packageRoot } from "./install-lib.mjs";
 import { setupWizard } from "./setup-wizard.mjs";
-import { startupPaths } from "../dist/startup.js";
-import { readEnvironment } from "../dist/environment.js";
-import { executorCommand, executorEnvironment } from "../dist/executor-runtime.js";
-import { acquireLauncherLock } from "../dist/lock.js";
+import { startupPaths, loadConfig, readEnvironment } from "../dist/configuration/files.js";
+import { configSchema } from "../dist/configuration/contract.js";
+import { validateConfig, coordinatorCredentialEnv } from "../dist/configuration/policy.js";
+import { validateServiceEnvironment, parseEnvironment } from "../dist/configuration/environment.js";
+import { checkDataDirectory } from "../dist/infrastructure/private-files.js";
 
 process.umask(0o077);
 let unlock;
 try {
   const options = argumentsFor(process.argv.slice(2));
   if (options.help) {
-    console.log("Usage: agent-task setup [--home ABSOLUTE_PRIVATE_DIR]\nInteractive on a terminal for a new installation. Noninteractive: --executors pi,codex,claude,opencode|none --cwd ABSOLUTE_DIR [--provider openai|anthropic|deepseek --model ID] [--port 8765]\nDefault: --prepare-only (no background service). --service explicitly installs/starts the background service.\nExisting installation: --check [--probe] | --resume. No credentials accepted on the command line. Existing configuration is never replaced.");
+    console.log("Usage: agent-task setup [--home ABSOLUTE_PRIVATE_DIR]\nNew installation: confirm directories, port, tokens and coordinator in the terminal.\nNoninteractive: --home DIR --data-dir DIR --port NUMBER --generate-tokens|--credentials-file PRIVATE_JSON --yes [--provider openai|anthropic|deepseek|openai-compatible --model ID]\nCompatible provider: --base-url URL --api openai-completions|openai-responses --api-key-env NAME --context-window NUMBER --max-tokens NUMBER\nExisting installation: --check | --resume. Secrets are read from a private JSON file or hidden terminal input, never command arguments. No executor installation during setup.");
     process.exit(0);
   }
-  if (options.service && (options["prepare-only"] || options.check)) throw new Error("--service cannot be combined with --prepare-only or --check");
-  if (options.probe && !options.check) throw new Error("--probe requires --check");
-  const root = installRoot(options), manifestPath = join(root, "installation.json");
-  if (!existsSync(manifestPath) && !options.check && !options.resume && (!options.executors || !options.cwd)) await setupWizard(options, root);
-  if (!existsSync(root)) mkdirSync(root, { recursive: true, mode: 0o700 });
-  if (realpathSync(root) !== root || lstatSync(root).uid !== process.getuid() || (lstatSync(root).mode & 0o077)) throw new Error("Installation home must be canonical, owned and private");
-  unlock = operationLock(root);
-  let manifest;
-  if (existsSync(manifestPath)) {
+  let root = installRoot(options);
+  if (!existsSync(join(root, "installation.json")) && !options.check && !options.resume && !options.yes) {
+    await setupWizard(options, root); root = installRoot(options);
+  }
+  let manifest, initialEnvironment;
+  if (existsSync(join(root, "installation.json"))) {
     manifest = readManifest(root);
-    if (["executors", "cwd", "provider", "model", "port"].some(key => options[key] !== undefined)) throw new Error("Installation already exists; initialization options cannot replace existing configuration");
-    if (manifest.phase !== "ready" && !options.resume) throw new Error("Incomplete or uninstalled components; use --resume explicitly (configuration will be preserved)");
+    if (Object.keys(options).some(key => !["home", "check", "resume"].includes(key))) throw new Error("Installation exists; use configuration commands instead of initialization flags");
+    if (manifest.phase !== "ready" && !options.resume) throw new Error("Incomplete initialization; inspect private files and use --resume explicitly");
   } else {
-    if (options.check || options.probe || options.resume) throw new Error("No installation to check/resume");
-    if (!options.executors || !options.cwd) throw new Error("Select --executors pi,codex,claude,opencode|none and --cwd ABSOLUTE_DIR");
-    const selected = options.executors === "none" ? [] : options.executors.split(",");
-    if (selected.some(id => !Object.hasOwn(packages, id)) || new Set(selected).size !== selected.length) throw new Error("Invalid executor selection");
-    if (!options.cwd.startsWith("/") || !lstatSync(realpathSync(options.cwd)).isDirectory()) throw new Error("cwd must be an existing absolute directory");
-    const cwd = realpathSync(options.cwd);
-    if ([root, packageRoot].some(path => cwd === path || cwd.startsWith(path + "/"))) throw new Error("Workspace must be outside the installation home and npm package");
-    if (Boolean(options.provider) !== Boolean(options.model) || (options.provider && !["openai", "anthropic", "deepseek"].includes(options.provider))) throw new Error("Specify a supported --provider together with --model");
-    const port = Number(options.port ?? 8765);
-    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error("Invalid port");
-    // Reject unowned artifacts. This script never adopts or clears an existing installation.
-    for (const name of ["components", "launch.json", "data"]) {
-      if (existsSync(join(root, name))) throw new Error("Existing unowned installation artifact: " + name);
-    }
-    manifest = { project: "agent-task", root, home: homedir(), platform: process.platform, node: process.execPath, app: packageRoot,
-      selected, cwd, port, coordinator: options.provider ? { provider: options.provider, model: options.model } : undefined,
-      phase: "installing", serviceInstalled: false, files: [] };
-    createFile(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
-  }
-  verifyServiceFile(manifest);
-  const app = manifest.app, components = join(root, "components");
-  if (!existsSync(join(app, "dist/main.js"))) throw new Error("Prebuilt runtime is missing; reinstall the npm package (source contributors: npm run build)");
-  if (manifest.phase !== "ready") {
-    if (manifest.serviceInstalled) throw new Error("Stop/uninstall the existing service before rebuilding components");
-    for (const name of ["components"]) {
-      if (!existsSync(join(root, name))) continue;
-      const known = new Set(manifest.files);
-      if (inventory(root, name).some(file => !known.has(file))) throw new Error("Uninventoried component files exist; refusing to overwrite them during resume");
+    if (options.check || options.resume) throw new Error("No installation to check/resume");
+    if (!options.yes || !options.home || !options["data-dir"] || options.port === undefined ||
+      (!options["generate-tokens"] && !options["credentials-file"])) throw new Error("Confirm initialization with --home, --data-dir, --port, --generate-tokens/--credentials-file and --yes");
+    const dataDir = installRoot({ home: options["data-dir"] });
+    if (dataDir === root || dataDir === packageRoot || dataDir.startsWith(packageRoot + "/")) throw new Error("Data directory must be separate from the installation root and npm package");
+    const coordinator = !options.provider || options.provider === "none" ? undefined : {
+      provider: options.provider, model: options.model,
+      ...(options.provider === "openai-compatible" ? { baseUrl: options["base-url"], api: options.api,
+        apiKeyEnv: options["api-key-env"], contextWindow: Number(options["context-window"]), maxTokens: Number(options["max-tokens"]), reasoning: false } : {}),
+    };
+    const config = validateConfig(configSchema.parse({ dataDir, port: Number(options.port), tokenEnv: options["token-env"] ?? "AGENT_TASK_TOKEN", coordinator, disabledExecutors: [] }));
+    initialEnvironment = options["credentials-file"] ? parseEnvironment(JSON.stringify(json(options["credentials-file"]))) : {};
+    if (options["generate-tokens"]) {
+      if (initialEnvironment[config.tokenEnv] || initialEnvironment.AGENT_TASK_ADMIN_TOKEN) throw new Error("Choose either supplied service/admin tokens or generated tokens");
+      initialEnvironment[config.tokenEnv] = randomBytes(32).toString("hex");
+      initialEnvironment.AGENT_TASK_ADMIN_TOKEN = randomBytes(32).toString("hex");
     }
-    try {
-      console.log("Using the prebuilt npm runtime. No source checkout or compilation required.");
-      mkdirSync(components, { recursive: true, mode: 0o700 });
-      if (!existsSync(join(components, "package.json"))) createFile(join(components, "package.json"), JSON.stringify({ private: true }));
-      const dependencies = manifest.selected.flatMap(id => packages[id]);
-      if (dependencies.length) {
-        console.log("Installing selected ACP executors into private components (not global executables).");
-        const installArgs = existsSync(join(components, "package-lock.json"))
-          ? ["ci", "--ignore-scripts", "--no-audit", "--no-fund"]
-          : ["install", "--save-exact", "--ignore-scripts", "--no-audit", "--no-fund", ...dependencies];
-        run("npm", installArgs, { cwd: components });
-        if (manifest.selected.includes("opencode")) {
-          // This pinned package requires copying its platform binary. No other lifecycle scripts run.
-          run(manifest.node, [join(components, "node_modules/opencode-ai/postinstall.mjs")], { cwd: components });
-        }
-      }
-      mkdirSync(join(root, "data/results"), { recursive: true, mode: 0o700 });
-      const dataDir = join(root, "data");
-      if (!existsSync(join(root, "launch.json"))) createFile(join(root, "launch.json"), JSON.stringify({ dataDir }) + "\n");
-      if (!existsSync(join(dataDir, "environment.json"))) createFile(join(dataDir, "environment.json"), JSON.stringify({ AGENT_TASK_TOKEN: randomBytes(32).toString("hex"), AGENT_TASK_ADMIN_TOKEN: randomBytes(32).toString("hex") }, null, 2) + "\n");
-      if (!existsSync(join(dataDir, "config.json"))) createFile(join(dataDir, "config.json"), JSON.stringify({ dataDir, port: manifest.port,
-        tokenEnv: "AGENT_TASK_TOKEN", coordinator: manifest.coordinator,
-        executors: manifest.selected.map(id => ({ id, type: id, note: "", cwd: manifest.cwd, unattendedApproved: false })) }, null, 2) + "\n");
-      manifest.phase = "ready";
-      delete manifest.port; delete manifest.cwd; delete manifest.coordinator;
-    } finally {
-      manifest.files = ["components"].filter(name => existsSync(join(root, name))).flatMap(name => inventory(root, name));
-      saveManifest(root, manifest);
+    if (coordinator && options.coordinatorKey) initialEnvironment[coordinatorCredentialEnv(config.coordinator)] = options.coordinatorKey;
+    validateServiceEnvironment(config, initialEnvironment);
+    if (!initialEnvironment.AGENT_TASK_ADMIN_TOKEN) throw new Error("An independent administrator token is required for initialization");
+    if (coordinator && !initialEnvironment[coordinatorCredentialEnv(config.coordinator)]) throw new Error("Coordinator credential is missing; supply it through the private credentials file");
+    for (const path of [join(root, "launch.json"), join(dataDir, "config.json"), join(dataDir, "environment.json")]) {
+      if (existsSync(path)) throw new Error("Existing unowned initialization file; refusing to overwrite: " + path);
     }
+    checkDataDirectory(root); checkDataDirectory(dataDir);
+    manifest = { project: "agent-task", root, home: homedir(), platform: process.platform, node: process.execPath,
+      app: packageRoot, phase: "initializing", dataDir, config };
   }
-  const paths = startupPaths(root), env = runtimeBaseEnv(manifest);
-  // Use the same native launch environment; private values are read separately, never passed to probes.
-  run(manifest.node, ["--input-type=module", "-e", `import {loadConfig} from ${JSON.stringify(pathToFileURL(join(app, "dist/config.js")).href)}; loadConfig(process.argv[1]);`, paths.configPath], { env });
-  const config = json(paths.configPath);
-  for (const id of manifest.selected) {
-    const cliEnv = executorEnvironment(env, readEnvironment(paths.environmentPath), config);
-    executorCommand(id, cliEnv); // No native process is launched without an explicit --probe.
-  }
-  const report = { platform: process.platform, dependencies: "ready", configuration: "valid", background: "not-checked",
-    coordinator: config.coordinator ? "configured; authentication not verified" : "not configured; task admission disabled",
-    executors: config.executors.map(executor => ({ id: executor.id, authorized: executor.unattendedApproved,
-      handshake: "not checked", execution: "not verified by setup" })) };
-  if (options.probe) {
-    for (const entry of report.executors) {
-      try { run(manifest.node, [join(app, "scripts/probe-agent.mjs"), paths.configPath, entry.id], { env, timeout: 20000 }); entry.handshake = "passed (initialize only)"; }
-      catch { entry.handshake = "failed; inspect native dependencies/configuration separately"; process.exitCode = 1; }
+  mkdirSync(root, { recursive: true, mode: 0o700 });
+  if (realpathSync(root) !== root || lstatSync(root).uid !== process.getuid() || (lstatSync(root).mode & 0o077)) throw new Error("Installation home must be canonical, owned and private");
+  unlock = operationLock(root);
+  if (!existsSync(join(root, "installation.json"))) createFile(join(root, "installation.json"), JSON.stringify(manifest, null, 2) + "\n");
+  if (!existsSync(join(packageRoot, "dist/application/main.js"))) throw new Error("Prebuilt runtime missing; reinstall the package");
+  if (manifest.phase !== "ready") {
+    if (!isAbsolute(manifest.dataDir) || !manifest.config) throw new Error("Incomplete installation record; no repair performed");
+    const dataDir = manifest.dataDir;
+    mkdirSync(dataDir, { recursive: true, mode: 0o700 }); checkDataDirectory(dataDir);
+    const environmentPath = join(dataDir, "environment.json"), configPath = join(dataDir, "config.json");
+    if (!existsSync(environmentPath)) {
+      if (!initialEnvironment) throw new Error("Initialization has no saved credentials; inspect the private directory before resuming");
+      createFile(environmentPath, JSON.stringify(initialEnvironment, null, 2) + "\n");
     }
+    if (!existsSync(configPath)) createFile(configPath, JSON.stringify(manifest.config, null, 2) + "\n");
+    const config = loadConfig(configPath), environment = readEnvironment(environmentPath);
+    if (JSON.stringify(config) !== JSON.stringify(manifest.config)) throw new Error("Saved initialization configuration differs; no repair performed");
+    validateServiceEnvironment(config, environment);
+    if (!existsSync(join(root, "launch.json"))) createFile(join(root, "launch.json"), JSON.stringify({ dataDir }) + "\n");
+    if (startupPaths(root).dataDir !== dataDir) throw new Error("Launch locator differs from initialization");
+    manifest.phase = "ready"; delete manifest.config; delete manifest.dataDir;
+    saveManifest(root, manifest);
   }
-  if (options.service) {
-    if (!manifest.serviceInstalled) acquireLauncherLock(root)(); // Refuse a live foreground owner.
-    // Record intent before activating so a failed service start is still owned by uninstall.
-    manifest.serviceInstalled = true; saveManifest(root, manifest);
-    activate(manifest);
-    report.background = "service manager registered";
-  }
-  if (manifest.serviceInstalled) {
-    try {
-      await checkHealth(root, 15000);
-      report.background = "authenticated MCP health check passed";
-    } catch { report.background = "not ready; run --check after startup and inspect the service manager"; process.exitCode = 1; }
-  }
-  console.log(JSON.stringify(report, null, 2));
-  console.log(`Config: ${paths.configPath}\nSecrets (never printed): ${paths.environmentPath}\nInstalled ACP adapters: ${join(components, "node_modules/.bin")}. Prepare authentication with each executor\'s official native tools under the service OS user. No login is performed by setup.\nConsole: http://127.0.0.1:${config.port}/admin/ (use the separate AGENT_TASK_ADMIN_TOKEN from the private environment file; never place it in a URL). Configure coordinator credentials there or in environment.json, and audit native executor permissions before setting unattendedApproved=true. No permissions are granted by setup. Use Web restart or agent-task restart after changes.\nLinux: user service requires lingering for logout survival (administrator decision). macOS: LaunchAgent survives terminal close, not user logout; log in again to restart. Neither platform executes during sleep/shutdown.`);
+  const paths = startupPaths(root), config = loadConfig(paths.configPath);
+  validateServiceEnvironment(config, readEnvironment(paths.environmentPath));
+  console.log(JSON.stringify({ configuration: "valid", coordinator: config.coordinator ? "configured; authentication not verified" : "not configured",
+    configPath: paths.configPath, credentialsPath: paths.environmentPath, executorDiscovery: "on MCP connection" }, null, 2));
+  if (!options.check) console.log("Add agent-task with args [mcp] to your MCP client (include --home for a custom installation). Token values are not printed. Use agent-task start for foreground management.");
 } catch (error) {
-  console.error(error.message); process.exitCode = 1;
+  console.error(error.name === "ZodError" ? "Invalid initialization configuration; check provider, model, directories and port" : error.message);
+  process.exitCode = 1;
 } finally { unlock?.(); }

package/deploy/agent-task.service.example

@@ -1,17 +0,0 @@
-[Unit]
-Description=Agent Task local service
-StartLimitIntervalSec=60
-StartLimitBurst=3
-
-[Service]
-Type=simple
-WorkingDirectory=/absolute/path/to/agent-task
-ExecStart=/absolute/path/to/node /absolute/path/to/agent-task/scripts/service-runner.mjs %h/.local/share/agent-task
-Restart=on-failure
-RestartSec=5
-TimeoutStopSec=45
-KillMode=control-group
-UMask=0077
-
-[Install]
-WantedBy=default.target

package/dist/admin.js

@@ -1,31 +0,0 @@
-import { readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { loadConfig, validateConfig } from "./config.js";
-import { replacePrivateText } from "./private-files.js";
-import { executorSchema } from "./model.js";
-import { acquireLock } from "./lock.js";
-process.umask(0o077);
-const [action, configPath, profilePath] = process.argv.slice(2);
-if (!configPath || !["register", "list"].includes(action ?? "") || (action === "register" && !profilePath)) {
-    throw new Error("Usage: node dist/admin.js list CONFIG | register CONFIG PROFILE.json (service stopped)");
-}
-const path = resolve(configPath), config = loadConfig(path);
-const release = await acquireLock(dirname(path));
-try {
-    if (action === "list") {
-        console.log(JSON.stringify(config.executors.map(executor => ({ ...executor, transport: "stdio" })), null, 2));
-    }
-    else {
-        const profile = executorSchema.parse(JSON.parse(readFileSync(resolve(profilePath), "utf8")));
-        if (config.executors.some(item => item.id === profile.id))
-            throw new Error("Executor ID already registered; edit reviewed config while stopped to replace");
-        config.executors.push(profile);
-        // Validate the complete candidate before publication, using the same rules as startup and the console.
-        replacePrivateText(path, JSON.stringify(validateConfig(config), null, 2) + "\n");
-        console.log(JSON.stringify({ registered: profile.id, transport: "stdio" }));
-    }
-}
-finally {
-    await release();
-}
-//# sourceMappingURL=admin.js.map

package/dist/config.js

@@ -1,72 +0,0 @@
-import { realpathSync, statSync } from "node:fs";
-import { isAbsolute } from "node:path";
-import { z } from "zod";
-import { executorSchema } from "./model.js";
-import { readPrivateText } from "./private-files.js";
-export const ADMIN_TOKEN_ENV = "AGENT_TASK_ADMIN_TOKEN";
-const envKey = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
-const baseEnvKeys = ["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH", "__proto__", "constructor", "prototype"];
-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();
-export function coordinatorCredentialEnv(config) {
-    switch (config.provider) {
-        case "openai": return "OPENAI_API_KEY";
-        case "anthropic": return "ANTHROPIC_API_KEY";
-        case "deepseek": return "DEEPSEEK_API_KEY";
-        case "openai-compatible": return config.apiKeyEnv;
-    }
-}
-export function loadConfig(path) {
-    let value;
-    try {
-        value = JSON.parse(readPrivateText(path));
-    }
-    catch {
-        throw new Error("Cannot read configuration JSON");
-    }
-    return validateConfig(value);
-}
-export function validateConfig(value) {
-    const config = configSchema.parse(value);
-    if (!isAbsolute(config.dataDir) || /[\x00-\x1f\x7f]/.test(config.dataDir))
-        throw new Error("dataDir must be absolute without control characters");
-    const coordinatorKey = config.coordinator ? coordinatorCredentialEnv(config.coordinator) : undefined;
-    if (/^(NODE_|LD_|DYLD_)/.test(config.tokenEnv) || [...baseEnvKeys, ADMIN_TOKEN_ENV, "OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY", coordinatorKey].includes(config.tokenEnv))
-        throw new Error("tokenEnv must be separate from base environment, administrator and model credentials");
-    if (coordinatorKey === ADMIN_TOKEN_ENV)
-        throw new Error("Administrator token must not be used as a model credential");
-    const ids = new Set();
-    for (const executor of config.executors) {
-        if (ids.has(executor.id))
-            throw new Error("Duplicate executor ID");
-        ids.add(executor.id);
-        if (!isAbsolute(executor.cwd))
-            throw new Error("Executor cwd must be absolute");
-        executor.cwd = realpathSync(executor.cwd);
-        if (!statSync(executor.cwd).isDirectory())
-            throw new Error("Invalid executor cwd");
-    }
-    return config;
-}
-//# sourceMappingURL=config.js.map

package/dist/executor-runtime.js

@@ -1,37 +0,0 @@
-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/lock.js

@@ -1,43 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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/model.js

@@ -1,25 +0,0 @@
-import { z } from "zod";
-export const timestamp = z.string().datetime({ offset: true }).transform(value => new Date(value).toISOString());
-export const identifier = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/);
-export const scheduleSchema = z.discriminatedUnion("type", [
-    z.object({ type: z.literal("now") }).strict(),
-    z.object({ type: z.literal("once"), at: timestamp }).strict(),
-    z.object({ type: z.literal("interval"), startAt: timestamp,
-        seconds: z.number().int().min(60).max(31_536_000) }).strict(),
-]);
-export const executorSchema = z.object({
-    id: identifier,
-    type: z.enum(["pi", "codex", "claude", "opencode"]),
-    note: z.string().max(2000).default(""),
-    cwd: z.string().min(1),
-    unattendedApproved: z.boolean().default(false),
-}).strict();
-export const OUTPUT_LIMIT = 262_144;
-export const EVENT_LIMIT = 2000;
-export const GRACE_MS = 30_000;
-export function iso(now = Date.now()) { return new Date(now).toISOString(); }
-export function errorText(error) { return (error instanceof Error ? error.message : String(error)).slice(0, 2000); }
-export function initialTime(schedule, now) {
-    return schedule.type === "now" ? now : Date.parse(schedule.type === "once" ? schedule.at : schedule.startAt);
-}
-//# sourceMappingURL=model.js.map