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

package/dist/executors/validation.js

@@ -1,10 +1,9 @@
 import { z } from "zod";
 import { absolutePath, identifier } from "../shared/validation.js";
+export const executorTypeSchema = z.enum(["pi", "codex", "claude", "opencode"]);
 export const executorRecord = z.object({
-    id: identifier, type: z.enum(["pi", "codex", "claude", "opencode"]),
-    note: z.string().max(2000), cwd: absolutePath, unattendedApproved: z.boolean(),
+    id: identifier, type: executorTypeSchema, nativePath: absolutePath,
+    command: absolutePath, args: z.array(z.string().max(4000)).max(100),
+    adapterVersion: z.string().min(1).max(200).nullable(),
 }).strict();
-export const executorSchema = executorRecord.extend({
-    note: executorRecord.shape.note.default(""), unattendedApproved: z.boolean().default(false),
-});
 //# sourceMappingURL=validation.js.map

package/dist/infrastructure/lock.js

@@ -1,21 +1,33 @@
 import { DatabaseSync } from "./sqlite.js";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 /** The stable installation lock prevents two launchers 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");
+export async function acquireLauncherLock(home) {
+    const deadline = Date.now() + 1500;
+    for (;;) {
+        const db = new DatabaseSync(join(home, "launcher-lock.sqlite"));
+        try {
+            db.exec("PRAGMA busy_timeout=0; BEGIN EXCLUSIVE");
+        }
+        catch (error) {
+            db.close();
+            const code = error.errcode;
+            if (code !== 5 && code !== 6)
+                throw new Error("Cannot acquire launcher ownership; inspect the installation filesystem", { cause: error });
+            if (Date.now() >= deadline)
+                throw new Error("Another launcher owns this installation", { cause: error });
+            // On a new SQLite file, concurrent readers can all lose the first exclusive-lock attempt.
+            // Release each failed connection and stagger retries before any service work starts.
+            await delay(25 + Math.floor(Math.random() * 25));
+            continue;
+        }
+        let released = false;
+        return () => { if (!released) {
+            db.close();
+            released = true;
+        } };
     }
-    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.

package/dist/infrastructure/workspace.js

@@ -1,16 +1,17 @@
 import { realpathSync, statSync } from "node:fs";
 import { isAbsolute } from "node:path";
+import { TaskError } from "../shared/errors.js";
 /** Path validity only; native executor policy owns directory and tool access. */
 export function resolveWorkspace(path) {
     if (!path || path.includes("\0") || !isAbsolute(path))
-        throw new Error("Workspace must be an absolute directory path");
+        throw new TaskError("validation", "Workspace must be an absolute directory path");
     const canonical = realpathSync(path);
     if (!statSync(canonical).isDirectory())
-        throw new Error("Workspace must be an existing directory");
+        throw new TaskError("validation", "Workspace must be an existing directory");
     return canonical;
 }
 export function checkWorkspace(path) {
     if (resolveWorkspace(path) !== path)
-        throw new Error("Workspace path changed since admission");
+        throw new TaskError("conflict", "Workspace path changed since admission");
 }
 //# sourceMappingURL=workspace.js.map

package/dist/integrations/acp/connection.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { Readable, Writable } from "node:stream";
 import { setTimeout as delay } from "node:timers/promises";
 import * as acp from "@agentclientprotocol/sdk";
-import { executorCommand } from "./runtime.js";
+import { executorLaunch } from "./runtime.js";
 import { Results } from "../../results/service.js";
 import { LocalResultFiles } from "../../results/files.js";
 import { permissionDecision } from "../../executors/permissions.js";
@@ -48,12 +48,12 @@ export async function terminateGroup(child) {
     child.stdout?.destroy();
     child.stderr?.destroy();
 }
-export async function openAcp(executor, signal, emit, resultsRoot, inputFiles = []) {
+export async function openAcp(executor, workspace, signal, emit, resultsRoot, inputFiles = []) {
     signal.throwIfAborted();
     const results = new Results(new LocalResultFiles(resultsRoot));
-    const launch = executorCommand(executor.type, process.env);
+    const launch = executorLaunch(executor, process.env);
     const child = spawn(launch.command, launch.args, {
-        cwd: executor.cwd, env: process.env, detached: true, stdio: ["pipe", "pipe", "pipe"],
+        cwd: workspace, env: launch.env, detached: true, stdio: ["pipe", "pipe", "pipe"],
     });
     const controller = new AbortController();
     const cancel = AbortSignal.any([signal, controller.signal]);
@@ -136,7 +136,7 @@ export async function openAcp(executor, signal, emit, resultsRoot, inputFiles =
         if (init.protocolVersion !== acp.PROTOCOL_VERSION)
             throw new Error("Incompatible ACP protocol version");
         await report("agent", { name: init.agentInfo?.name ?? null, version: init.agentInfo?.version ?? null });
-        const session = await connection.agent.request(acp.methods.agent.session.new, { cwd: executor.cwd, mcpServers: [] });
+        const session = await connection.agent.request(acp.methods.agent.session.new, { cwd: workspace, mcpServers: [] });
         sessionId = session.sessionId;
         await report("session", sessionId);
         cancel.throwIfAborted();

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/integrations/acp/runtime.js

@@ -1,28 +1,43 @@
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, isAbsolute, join } from "node:path";
-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. */ }
+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;
         }
-        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] };
+        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/integrations/acp/worker.js

@@ -1,8 +1,10 @@
 import { openAcp } from "./connection.js";
 import { z } from "zod";
 import { errorText } from "../../shared/errors.js";
-import { executorSchema } from "../../executors/validation.js";
-const inputSchema = z.object({ executor: executorSchema, inputFiles: z.array(z.string()).max(20), resultsRoot: z.string().min(1) }).strict();
+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;
@@ -65,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/integrations/local-service/control.js

@@ -1,32 +1,57 @@
 import { request } from "node:http";
 import { join } from "node:path";
 import { startupPaths } from "../../configuration/files.js";
-/** Local administrator capability: the socket lives in the private launcher directory. */
-export function controlService(home, action) {
+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" }, res => {
+        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; });
+            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 Error("Service unavailable; inspect private logs and startup files"));
+                    reject(new ControlError("unavailable", "Service unavailable; inspect private logs and startup files"));
                     return;
                 }
                 try {
-                    resolve(JSON.parse(body));
+                    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 Error("Invalid launcher response"));
+                    reject(new ControlError("invalid", "Invalid launcher response"));
                 }
             });
+            res.once("error", () => reject(new ControlError("unavailable", "Launcher response interrupted; check status before another action")));
         });
-        req.setTimeout(60_000, () => { timedOut = true; req.destroy(); });
-        req.once("error", () => reject(new Error(timedOut
-            ? "Service control timed out; outcome is unknown, check status before another restart"
-            : "Cannot contact launcher; start the foreground or managed service first")));
+        req.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();
     });
 }