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

package/dist/integrations/acp/discovery.js

@@ -0,0 +1,271 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { constants, existsSync, lstatSync, openSync, closeSync, mkdirSync, readFileSync, realpathSync, writeFileSync, fsyncSync, renameSync, unlinkSync } from "node:fs";
+import { join, relative, dirname } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { acquireLock } from "../../infrastructure/lock.js";
+import { checkDataDirectory, readPrivateText } from "../../infrastructure/private-files.js";
+import { FileCommitError } from "../../shared/errors.js";
+import { checkExecutable, findExecutable } from "./runtime.js";
+const types = ["pi", "codex", "claude", "opencode"];
+const adapters = {
+    pi: { package: "pi-acp", bin: "pi-acp" },
+    codex: { package: "@agentclientprotocol/codex-acp", bin: "codex-acp" },
+    claude: { package: "@agentclientprotocol/claude-agent-acp", bin: "claude-agent-acp" },
+};
+const versionPattern = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const directoryPattern = /^installation-[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/;
+/** Owns managed adapter files. Discovery never installs a native CLI or starts an agent. */
+export class LocalExecutors {
+    adaptersRoot;
+    environment;
+    installing = new Map();
+    constructor(adaptersRoot, nativeEnvironment) {
+        this.adaptersRoot = adaptersRoot;
+        checkDataDirectory(adaptersRoot);
+        this.environment = { ...nativeEnvironment };
+    }
+    discover() {
+        const executors = [], states = [];
+        for (const type of types) {
+            const nativePath = this.nativePath(type);
+            const state = { id: type, type, nativePath, state: "missing", adapterVersion: null, error: null };
+            try {
+                const executor = nativePath ? this.installed(type, nativePath) : null;
+                if (executor) {
+                    executors.push(executor);
+                    state.state = "ready";
+                    state.adapterVersion = executor.adapterVersion;
+                }
+            }
+            catch {
+                state.state = "error";
+                state.error = "Managed ACP adapter is invalid; explicitly upgrade this executor to replace it";
+            }
+            if (this.installing.has(type))
+                state.state = "installing";
+            states.push(state);
+        }
+        return { executors, states };
+    }
+    install(type, upgrade, signal) {
+        const pending = this.installing.get(type);
+        if (pending)
+            return pending;
+        const installation = this.prepare(type, upgrade, signal).finally(() => { this.installing.delete(type); });
+        this.installing.set(type, installation);
+        return installation;
+    }
+    check(executor) {
+        if (executor.id !== executor.type || !types.includes(executor.type) || this.nativePath(executor.type) !== executor.nativePath) {
+            throw new Error("Native executor is missing or changed");
+        }
+        checkExecutable(executor.nativePath);
+        if (executor.type === "opencode") {
+            if (executor.command !== executor.nativePath || executor.adapterVersion !== null ||
+                executor.args.length !== 1 || executor.args[0] !== "acp")
+                throw new Error("Invalid OpenCode launch");
+        }
+        else {
+            const typeRoot = join(this.adaptersRoot, executor.type);
+            const directory = relative(typeRoot, executor.command).split("/")[0];
+            if (!directory || !directoryPattern.test(directory) || !executor.adapterVersion || executor.args.length) {
+                throw new Error("Invalid managed ACP launch");
+            }
+            const expected = this.adapter(executor.type, executor.nativePath, { directory, version: executor.adapterVersion });
+            if (expected.command !== executor.command)
+                throw new Error("Managed ACP executable changed");
+        }
+        checkExecutable(executor.command);
+    }
+    nativePath(type) {
+        return findExecutable(type, this.environment, this.adaptersRoot);
+    }
+    installed(type, nativePath) {
+        if (type === "opencode")
+            return { id: type, type, nativePath, command: nativePath, args: ["acp"], adapterVersion: null };
+        const path = join(this.adaptersRoot, type, "current.json");
+        if (!lstatSync(path, { throwIfNoEntry: false }))
+            return null;
+        let value;
+        try {
+            value = JSON.parse(readPrivateText(path));
+        }
+        catch {
+            throw new Error("Invalid adapter installation record");
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Invalid adapter installation record");
+        const record = value;
+        if (Object.keys(record).length !== 2 || typeof record.version !== "string" || typeof record.directory !== "string" ||
+            !versionPattern.test(record.version) || !directoryPattern.test(record.directory))
+            throw new Error("Invalid adapter installation record");
+        return this.adapter(type, nativePath, { version: record.version, directory: record.directory });
+    }
+    adapter(type, nativePath, installation) {
+        const root = join(this.adaptersRoot, type, installation.directory);
+        checkDataDirectory(root);
+        const entry = adapters[type];
+        const packageRoot = join(root, "node_modules", entry.package);
+        if (realpathSync(packageRoot) !== packageRoot)
+            throw new Error("Invalid managed ACP package directory");
+        const metadata = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+        if (metadata.name !== entry.package || metadata.version !== installation.version)
+            throw new Error("Managed ACP package version changed");
+        const command = realpathSync(join(root, "node_modules/.bin", entry.bin));
+        if (!command.startsWith(packageRoot + "/"))
+            throw new Error("Managed ACP executable is outside its package");
+        checkExecutable(command);
+        return { id: type, type, nativePath, command, args: [], adapterVersion: installation.version };
+    }
+    async prepare(type, upgrade, requestedSignal) {
+        const signal = AbortSignal.any([requestedSignal, AbortSignal.timeout(300_000)]);
+        signal.throwIfAborted();
+        const nativePath = this.nativePath(type);
+        if (!nativePath)
+            throw new Error("Native CLI is not installed: " + type);
+        if (type === "opencode")
+            return this.installed(type, nativePath);
+        if (!upgrade) {
+            const existing = this.installed(type, nativePath);
+            if (existing)
+                return existing;
+        }
+        checkDataDirectory(this.adaptersRoot);
+        mkdirSync(this.adaptersRoot, { recursive: true, mode: 0o700 });
+        const root = join(this.adaptersRoot, type);
+        checkDataDirectory(root);
+        mkdirSync(root, { mode: 0o700, recursive: true });
+        const unlock = await this.lock(root, signal);
+        try {
+            if (!upgrade) {
+                const existing = this.installed(type, nativePath);
+                if (existing)
+                    return existing;
+            }
+            const npm = findExecutable("npm", this.environment);
+            if (!npm)
+                throw new Error("npm is required to install ACP adapters");
+            const entry = adapters[type];
+            const versionText = await this.npm(npm, ["view", entry.package + "@latest", "version", "--json"], root, signal, true);
+            let version;
+            try {
+                version = JSON.parse(versionText);
+            }
+            catch {
+                throw new Error("Registry did not return an ACP adapter version");
+            }
+            if (typeof version !== "string" || version.length > 100 || !versionPattern.test(version))
+                throw new Error("Registry returned an invalid ACP adapter version");
+            const installation = { version, directory: "installation-" + randomUUID() };
+            const directory = join(root, installation.directory);
+            mkdirSync(directory, { mode: 0o700 });
+            writeFileSync(join(directory, "package.json"), JSON.stringify({ private: true }) + "\n", { flag: "wx", mode: 0o600 });
+            await this.npm(npm, ["install", "--global=false", "--prefix", directory, "--save-prod", "--save-exact",
+                "--package-lock=true", "--ignore-scripts", "--no-audit", "--no-fund", entry.package + "@" + version], directory, signal);
+            signal.throwIfAborted();
+            const executor = this.adapter(type, nativePath, installation);
+            this.check(executor);
+            signal.throwIfAborted();
+            this.publish(join(root, "current.json"), installation);
+            return executor;
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw new Error("ACP adapter installation was cancelled or timed out");
+            if (error instanceof FileCommitError && error.uncertain) {
+                throw new Error("ACP adapter publication could not be confirmed; inspect executor status before retrying");
+            }
+            // Never include npm diagnostics or parser excerpts in an API response.
+            if (error instanceof Error && /^(npm is required|Registry (did not return|returned)|Native executor is missing)/.test(error.message))
+                throw error;
+            throw new Error("ACP adapter installation failed; previous installed adapter was preserved");
+        }
+        finally {
+            await unlock();
+        }
+    }
+    async lock(root, signal) {
+        for (;;) {
+            signal.throwIfAborted();
+            try {
+                return await acquireLock(root);
+            }
+            catch (error) {
+                const code = error.cause?.errcode;
+                if (code !== 5 && code !== 6)
+                    throw new Error("Could not acquire ACP adapter installation ownership");
+                await delay(100, undefined, { signal });
+            }
+        }
+    }
+    npm(command, args, cwd, signal, capture = false) {
+        signal.throwIfAborted();
+        const env = Object.fromEntries(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR"].flatMap(key => this.environment[key] === undefined ? [] : [[key, this.environment[key]]]));
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, { cwd, env, detached: true, stdio: ["ignore", "pipe", "pipe"] });
+            let output = "", bytes = 0, failed = false;
+            const stop = () => {
+                failed = true;
+                if (child.pid) {
+                    try {
+                        process.kill(-child.pid, "SIGKILL");
+                    }
+                    catch { /* Wait for process close before releasing installation ownership. */ }
+                }
+            };
+            const receive = (chunk, stdout) => {
+                bytes += chunk.length;
+                if (bytes > 1_048_576)
+                    stop();
+                else if (capture && stdout)
+                    output += chunk.toString("utf8");
+            };
+            child.stdout.on("data", (chunk) => receive(chunk, true));
+            child.stderr.on("data", (chunk) => receive(chunk, false));
+            child.once("error", () => { failed = true; });
+            signal.addEventListener("abort", stop, { once: true });
+            child.once("close", code => {
+                signal.removeEventListener("abort", stop);
+                if (failed || signal.aborted || code !== 0)
+                    reject(new Error("npm operation failed"));
+                else
+                    resolve(output.trim());
+            });
+            if (signal.aborted)
+                stop();
+        });
+    }
+    publish(path, installation) {
+        const temporary = join(dirname(path), ".current-" + randomUUID() + ".tmp");
+        let fd, published = false;
+        try {
+            if (lstatSync(path, { throwIfNoEntry: false }))
+                readPrivateText(path);
+            fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+            writeFileSync(fd, JSON.stringify(installation) + "\n");
+            fsyncSync(fd);
+            closeSync(fd);
+            fd = undefined;
+            renameSync(temporary, path);
+            published = true;
+            const directory = openSync(dirname(path), constants.O_RDONLY);
+            try {
+                fsyncSync(directory);
+            }
+            finally {
+                closeSync(directory);
+            }
+        }
+        catch {
+            throw new FileCommitError(published);
+        }
+        finally {
+            if (fd !== undefined)
+                closeSync(fd);
+            if (existsSync(temporary))
+                unlinkSync(temporary);
+        }
+    }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/{node-execution.js → integrations/acp/execution.js}

@@ -99,4 +99,4 @@ export const createExecution = (environment) => (input, event, beforeStart) => {
         },
     };
 };
-//# sourceMappingURL=node-execution.js.map
+//# sourceMappingURL=execution.js.map

package/dist/integrations/acp/runtime.js

@@ -0,0 +1,43 @@
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+export function checkExecutable(path) {
+    if (!isAbsolute(path) || /[\x00-\x1f\x7f]/.test(path) || realpathSync(path) !== path || !statSync(path).isFile()) {
+        throw new Error("Expected a canonical executable path");
+    }
+    accessSync(path, constants.X_OK);
+}
+/** Resolve native executables without a shell or service-managed dependencies. */
+export function findExecutable(name, environment, excludedRoot) {
+    for (const directory of (environment.PATH ?? "").split(delimiter).filter(isAbsolute)) {
+        try {
+            const path = realpathSync(join(directory, name));
+            if (excludedRoot && (path === excludedRoot || path.startsWith(excludedRoot + "/")))
+                continue;
+            checkExecutable(path);
+            return path;
+        }
+        catch { /* Try the next native PATH entry. */ }
+    }
+    return null;
+}
+/** A stored launch binds the adapter to the native executable discovered for this Task. */
+export function executorLaunch(executor, environment) {
+    checkExecutable(executor.nativePath);
+    checkExecutable(executor.command);
+    if (executor.type === "opencode"
+        ? executor.command !== executor.nativePath || executor.args.length !== 1 || executor.args[0] !== "acp"
+        : executor.args.length !== 0)
+        throw new Error("Invalid ACP launch arguments");
+    const env = { ...environment };
+    delete env.PI_ACP_PI_COMMAND;
+    delete env.CODEX_PATH;
+    delete env.CLAUDE_CODE_EXECUTABLE;
+    if (executor.type === "pi")
+        env.PI_ACP_PI_COMMAND = executor.nativePath;
+    if (executor.type === "codex")
+        env.CODEX_PATH = executor.nativePath;
+    if (executor.type === "claude")
+        env.CLAUDE_CODE_EXECUTABLE = executor.nativePath;
+    return { command: executor.command, args: [...executor.args], env };
+}
+//# sourceMappingURL=runtime.js.map

package/dist/{worker.js → integrations/acp/worker.js}

@@ -1,7 +1,10 @@
-import { openAcp } from "./acp.js";
+import { openAcp } from "./connection.js";
 import { z } from "zod";
-import { errorText, executorSchema } from "./model.js";
-const inputSchema = z.object({ executor: executorSchema, inputFiles: z.array(z.string()).max(20), resultsRoot: z.string().min(1) }).strict();
+import { errorText } from "../../shared/errors.js";
+import { executorRecord } from "../../executors/validation.js";
+import { absolutePath } from "../../shared/validation.js";
+const inputSchema = z.object({ executor: executorRecord, workspace: absolutePath,
+    inputFiles: z.array(z.string()).max(20), resultsRoot: z.string().min(1) }).strict();
 const controller = new AbortController();
 const pending = new Map();
 let sequence = 0, started = false, busy = false;
@@ -64,7 +67,7 @@ process.on("message", (message) => {
         started = true;
         opening = (async () => {
             const input = inputSchema.parse(message.input);
-            session = await openAcp(input.executor, controller.signal, emit, input.resultsRoot, input.inputFiles);
+            session = await openAcp(input.executor, input.workspace, controller.signal, emit, input.resultsRoot, input.inputFiles);
             void session.closed.then(() => { if (!closing)
                 void fail(new Error("ACP process exited")); });
             if (!controller.signal.aborted)

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

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

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

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

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

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

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

@@ -0,0 +1,58 @@
+import { request } from "node:http";
+import { join } from "node:path";
+import { startupPaths } from "../../configuration/files.js";
+export class ControlError extends Error {
+    kind;
+    constructor(kind, message) {
+        super(message);
+        this.kind = kind;
+    }
+}
+export function controlService(home, action, timeout = 60_000) {
+    startupPaths(home);
+    return new Promise((resolve, reject) => {
+        let timedOut = false;
+        const req = request({ socketPath: join(home, "control.sock"), path: "/" + action, method: "POST", agent: false }, res => {
+            let body = "";
+            res.setEncoding("utf8");
+            res.on("data", chunk => {
+                body += chunk;
+                if (body.length > 16_384) {
+                    reject(new ControlError("invalid", "Invalid launcher response"));
+                    req.destroy();
+                }
+            });
+            res.on("end", () => {
+                if (res.statusCode !== 200) {
+                    reject(new ControlError("unavailable", "Service unavailable; inspect private logs and startup files"));
+                    return;
+                }
+                try {
+                    const value = JSON.parse(body);
+                    if (action === "stop") {
+                        if (value.stopped !== true)
+                            throw new Error();
+                        resolve({ stopped: true });
+                    }
+                    else {
+                        if (typeof value.instanceId !== "string" || typeof value.url !== "string" || !Number.isInteger(value.pid) ||
+                            !(value.consoleUrl === null || typeof value.consoleUrl === "string"))
+                            throw new Error();
+                        resolve(value);
+                    }
+                }
+                catch {
+                    reject(new ControlError("invalid", "Invalid launcher response"));
+                }
+            });
+            res.once("error", () => reject(new ControlError("unavailable", "Launcher response interrupted; check status before another action")));
+        });
+        req.setTimeout(timeout, () => { timedOut = true; req.destroy(); });
+        req.once("error", (error) => reject(new ControlError(timedOut ? "timeout"
+            : ["ENOENT", "ECONNREFUSED"].includes(error.code ?? "") ? "unreachable" : "unavailable", timedOut
+            ? "Service control timed out; check status before another action"
+            : "Cannot contact launcher; use agent-task mcp or start the service")));
+        req.end();
+    });
+}
+//# sourceMappingURL=control.js.map

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

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