@realqiyan/agent-task 0.0.0-stage → 0.0.1-rc.1

package/dist/results.js

@@ -0,0 +1,85 @@
+import { mkdirSync, openSync, closeSync, writeFileSync, readFileSync, fstatSync, fsyncSync, realpathSync, statSync, accessSync, constants } from "node:fs";
+import { join, relative, isAbsolute } from "node:path";
+import { OUTPUT_LIMIT } from "./model.js";
+/** Exact per-run file allowlist intersected with administrator-granted roots. Never offers general filesystem access. */
+export function readInputFile(executor, allowed, path, line = 1, limit) {
+    if (!allowed.includes(path) || realpathSync(path) !== path)
+        throw new Error("Input file is not authorized for this run");
+    if (!executor.resultReadRoots.some(root => {
+        const rel = relative(realpathSync(root), path);
+        return !rel.startsWith("..") && !isAbsolute(rel);
+    }))
+        throw new Error("Input file outside authorized read scope");
+    if (!Number.isInteger(line) || line < 1 || (limit !== undefined && (!Number.isInteger(limit) || limit < 1)))
+        throw new Error("Invalid line range");
+    const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || stat.size > OUTPUT_LIMIT)
+            throw new Error("Invalid or oversized input file");
+        const content = readFileSync(fd, "utf8");
+        if (Buffer.byteLength(content) > OUTPUT_LIMIT)
+            throw new Error("Input file grew beyond limit");
+        if (line === 1 && limit === undefined)
+            return content;
+        return content.split("\n").slice(line - 1, limit === undefined ? undefined : line - 1 + limit).join("\n");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+export class Results {
+    root;
+    constructor(directory) {
+        mkdirSync(join(directory, "results"), { recursive: true, mode: 0o700 });
+        this.root = realpathSync(join(directory, "results"));
+    }
+    inside(root, path) {
+        const rel = relative(root, path);
+        return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+    }
+    authorize(executor) {
+        if (!executor.resultReadRoots.some(root => this.inside(realpathSync(root), this.root))) {
+            throw new Error("Executor " + executor.id + " lacks administrator-approved result read scope");
+        }
+    }
+    readable(path, executor) {
+        this.authorize(executor);
+        if (realpathSync(path) !== path || !this.inside(this.root, path) || !statSync(path).isFile())
+            throw new Error("Invalid result file");
+        accessSync(path, constants.R_OK);
+        // Actually open it. Native agent sandbox access remains an administrator-reviewed prerequisite.
+        const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        closeSync(fd);
+    }
+    save(taskRunId, nodeId, runId, text) {
+        for (const id of [taskRunId, nodeId, runId]) {
+            if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,99}$/.test(id))
+                throw new Error("Invalid result identity");
+        }
+        const directory = join(this.root, taskRunId);
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        if (realpathSync(directory) !== directory)
+            throw new Error("Result directory must not be a symlink");
+        const path = join(directory, nodeId + "." + runId + ".txt");
+        const fd = openSync(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        try {
+            writeFileSync(fd, text, "utf8");
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        for (const dir of [directory, this.root]) {
+            const handle = openSync(dir, constants.O_RDONLY);
+            try {
+                fsyncSync(handle);
+            }
+            finally {
+                closeSync(handle);
+            }
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=results.js.map

package/dist/settings-contract.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { configSchema } from "./config.js";
+export const settingsConfigSchema = z.object({
+    editToken: z.string().uuid(),
+    config: configSchema.pick({ executors: true, coordinator: true }),
+}).strict();
+const credential = {
+    editToken: z.string().uuid(),
+    key: z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(200),
+};
+export const credentialUpdateSchema = z.discriminatedUnion("action", [
+    z.object({ ...credential, action: z.literal("replace"),
+        value: z.string().min(1).max(16_384).refine(value => Boolean(value.trim()) && !value.includes("\0")) }).strict(),
+    z.object({ ...credential, action: z.literal("delete") }).strict(),
+]);
+//# sourceMappingURL=settings-contract.js.map

package/dist/settings.js

@@ -0,0 +1,163 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { ADMIN_TOKEN_ENV, configSchema, coordinatorCredentialEnv, validateConfig } from "./config.js";
+import { parseEnvironment } from "./environment.js";
+import { FileCommitError, readPrivateText, replacePrivateText } from "./private-files.js";
+import { credentialUpdateSchema, settingsConfigSchema } from "./settings-contract.js";
+export class SettingsError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const protectedKeys = new Set(["HOME", "PATH", "LANG", "LC_ALL", "TZ", "TMPDIR", "NODE_OPTIONS", "NODE_PATH",
+    "PI_ACP_PI_COMMAND", "AGENT_TASK_TOKEN", ADMIN_TOKEN_ENV, "__proto__", "constructor", "prototype"]);
+const modelKeys = ["OPENAI_API_KEY", "ANTHROPIC_API_KEY", "DEEPSEEK_API_KEY"];
+function parse(schema, value) {
+    const result = schema.safeParse(value);
+    if (!result.success) {
+        // Field paths only: parser diagnostics and rejected values may contain credentials.
+        const fields = result.error.issues.slice(0, 8).map(issue => issue.path.join(".") || "request");
+        throw new SettingsError("invalid", "Invalid fields: " + fields.join(", "));
+    }
+    return result.data;
+}
+function referenced(config) {
+    return new Set([...config.executors.flatMap(executor => executor.envKeys),
+        ...(config.coordinator ? [coordinatorCredentialEnv(config.coordinator)] : [])]);
+}
+function editableKey(key, config) {
+    return !protectedKeys.has(key) && key !== config.tokenEnv && !/^(NODE_|LD_|DYLD_)/.test(key) &&
+        (/(?:_KEY|_TOKEN|_SECRET|_PASSWORD)$/.test(key) || referenced(config).has(key));
+}
+/** Disk settings are next-start inputs only. This service never mutates live objects or process.env. */
+export class Settings {
+    configPath;
+    environmentPath;
+    edits = new Map();
+    initial;
+    running;
+    runningEnvironment;
+    base;
+    closed = false;
+    uncertain = false;
+    startedAt = new Date().toISOString();
+    constructor(configPath, environmentPath, running, base, environment) {
+        this.configPath = configPath;
+        this.environmentPath = environmentPath;
+        if (configPath === environmentPath)
+            throw new SettingsError("invalid", "Configuration and environment must be separate files");
+        this.running = structuredClone(running);
+        this.base = { ...base };
+        this.runningEnvironment = { ...environment };
+        this.initial = this.snapshot();
+    }
+    snapshot() {
+        if (this.closed)
+            throw new SettingsError("unavailable", "Configuration management is closed");
+        try {
+            const configText = readPrivateText(this.configPath), environmentText = readPrivateText(this.environmentPath);
+            return { configText, environmentText, config: configSchema.parse(JSON.parse(configText)), environment: parseEnvironment(environmentText) };
+        }
+        catch {
+            throw new SettingsError("unavailable", "Cannot read private configuration files; inspect their format, ownership and permissions offline");
+        }
+    }
+    pending(snapshot) {
+        return snapshot.configText !== this.initial.configText || snapshot.environmentText !== this.initial.environmentText;
+    }
+    status() {
+        return { pendingRestart: this.pending(this.snapshot()), writeBlocked: this.uncertain, startedAt: this.startedAt };
+    }
+    get() {
+        const snapshot = this.snapshot(), now = Date.now();
+        for (const [key, edit] of this.edits)
+            if (edit.expires <= now)
+                this.edits.delete(key);
+        while (this.edits.size >= 32)
+            this.edits.delete(this.edits.keys().next().value);
+        const editToken = randomUUID();
+        this.edits.set(editToken, { configText: snapshot.configText, environmentText: snapshot.environmentText, expires: now + 15 * 60_000 });
+        const keys = new Set([...modelKeys, ...Object.keys(snapshot.environment), ...referenced(snapshot.config), ...referenced(this.running)]);
+        const credentials = [...keys].filter(key => editableKey(key, snapshot.config)).sort().map(key => ({
+            key, saved: Boolean(snapshot.environment[key]), running: Boolean(this.runningEnvironment[key]),
+            pendingRestart: snapshot.environment[key] !== this.runningEnvironment[key],
+            referenced: referenced(snapshot.config).has(key),
+        }));
+        return { editToken, running: structuredClone(this.running), saved: snapshot.config, credentials,
+            pendingRestart: this.pending(snapshot), writeBlocked: this.uncertain };
+    }
+    editing(token) {
+        if (this.uncertain)
+            throw new SettingsError("unavailable", "Publication was uncertain; stop the service and inspect configuration files before further saves");
+        const snapshot = this.snapshot(), edit = this.edits.get(token);
+        if (!edit || edit.expires <= Date.now() || edit.configText !== snapshot.configText || edit.environmentText !== snapshot.environmentText) {
+            throw new SettingsError("conflict", "Configuration changed or the edit expired; reload before saving");
+        }
+        return snapshot;
+    }
+    candidate(value) {
+        const input = parse(settingsConfigSchema, value), snapshot = this.editing(input.editToken);
+        const environment = { ...this.base, ...snapshot.environment };
+        let config;
+        try {
+            config = validateConfig({ ...snapshot.config, ...input.config, coordinator: input.config.coordinator }, environment);
+        }
+        catch (error) {
+            if (error instanceof z.ZodError)
+                throw new SettingsError("invalid", "Invalid configuration fields");
+            throw new SettingsError("invalid", "Local validation failed: check executable paths, dependencies, workspaces, read roots and credential isolation");
+        }
+        const previous = snapshot.config.coordinator, next = config.coordinator;
+        const endpoint = (model) => model.provider === "openai-compatible" ? model.baseUrl : model.provider;
+        if (previous && next && endpoint(previous) !== endpoint(next) && coordinatorCredentialEnv(previous) === coordinatorCredentialEnv(next)) {
+            throw new SettingsError("invalid", "Changing the model endpoint requires a new credential reference; save the new key first");
+        }
+        for (const key of referenced(config)) {
+            if (!environment[key])
+                throw new SettingsError("invalid", "A referenced environment value is missing; prepare credentials or native configuration first");
+        }
+        return config;
+    }
+    validate(value) { return this.candidate(value); }
+    saveConfig(value) {
+        const config = this.candidate(value);
+        this.publish(this.configPath, config);
+        return this.get();
+    }
+    saveCredential(value) {
+        const input = parse(credentialUpdateSchema, value), snapshot = this.editing(input.editToken);
+        if (!editableKey(input.key, snapshot.config))
+            throw new SettingsError("invalid", "This environment key is not console-managed; new credential names must end in _KEY, _TOKEN, _SECRET or _PASSWORD");
+        if (input.action === "delete") {
+            if (referenced(snapshot.config).has(input.key))
+                throw new SettingsError("invalid", "The saved configuration still references this credential");
+            delete snapshot.environment[input.key];
+        }
+        else {
+            if ([snapshot.environment[snapshot.config.tokenEnv], snapshot.environment[ADMIN_TOKEN_ENV],
+                this.runningEnvironment[this.running.tokenEnv], this.runningEnvironment[ADMIN_TOKEN_ENV]].includes(input.value)) {
+                throw new SettingsError("invalid", "Service and administrator tokens cannot be reused as credentials");
+            }
+            snapshot.environment[input.key] = input.value;
+        }
+        // Recheck the complete environment format, not only the edited value.
+        parseEnvironment(JSON.stringify(snapshot.environment));
+        this.publish(this.environmentPath, snapshot.environment);
+        return this.get();
+    }
+    publish(path, value) {
+        try {
+            replacePrivateText(path, JSON.stringify(value, null, 2) + "\n");
+        }
+        catch (error) {
+            if (error instanceof FileCommitError && error.uncertain)
+                this.uncertain = true;
+            throw new SettingsError("unavailable", this.uncertain ? "Publication could not be confirmed; stop and inspect the files" : "Save failed; no replacement was published");
+        }
+        this.edits.clear();
+    }
+    close() { this.closed = true; this.edits.clear(); }
+}
+//# sourceMappingURL=settings.js.map

package/dist/task-contract.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { isAbsolute } from "node:path";
+import { identifier, scheduleSchema, timestamp } from "./model.js";
+export const nodeSchema = z.object({
+    id: identifier, prompt: z.string().trim().min(1).max(64_000),
+    executorId: identifier.describe("Administrator-registered ACP executor assigned to this node; not a command or URL."),
+    dependsOn: z.array(identifier).max(20).default([]),
+    maxRunSeconds: z.number().int().min(1).max(3600).default(600),
+}).strict();
+export const questionSchema = z.object({
+    nodeId: identifier.optional(), question: z.string().trim().min(1).max(4000),
+    completedWork: z.string().trim().min(1).max(4000),
+}).strict();
+export const replySchema = z.object({
+    runId: z.string().uuid(), questionId: z.string().uuid(), requestKey: identifier,
+    answer: z.string().trim().min(1).max(16000),
+}).strict();
+export const taskIdSchema = z.object({ id: z.string().uuid() }).strict();
+export const taskListSchema = z.object({
+    after: z.number().int().nonnegative().default(0), limit: z.number().int().min(1).max(100).default(20),
+}).strict();
+export const taskRunListSchema = taskListSchema.extend({ taskId: z.string().uuid().optional() });
+export const taskUpdateSchema = z.object({
+    id: z.string().uuid(), action: z.enum(["pause", "resume", "cancel"]),
+}).strict();
+export const taskSchema = z.object({
+    requestKey: identifier, name: z.string().trim().min(1).max(200),
+    prompt: z.string().trim().min(1).max(64_000).describe("Overall goal and coordination constraints; does not generate or replace the DAG."),
+    nodes: z.array(nodeSchema).min(1).max(20).describe("Caller-defined fixed DAG. Each node specifies its prompt, executorId and direct dependencies."),
+    workspace: z.string().min(1).max(4096).refine(path => isAbsolute(path) && !path.includes("\0"), "Workspace must be an absolute path without NUL").optional(),
+    schedule: scheduleSchema, expiresAt: timestamp.optional(),
+    maxRunSeconds: z.number().int().min(1).max(86_400).default(1800),
+    maxSteps: z.number().int().min(1).max(200).default(40),
+    maxNodeTurns: z.number().int().min(1).max(10).default(3),
+    inputWaitSeconds: z.number().int().min(1).max(604800).default(86400),
+}).strict();
+//# sourceMappingURL=task-contract.js.map

package/dist/task-model.js

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

package/dist/task-storage.js

@@ -0,0 +1,123 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { executorSchema, identifier, timestamp } from "./model.js";
+import { nodeSchema, questionSchema, taskSchema } from "./task-contract.js";
+const definitionSchema = z.object({
+    id: z.string().uuid(), input: taskSchema, workspace: z.string().nullable(), executors: z.record(identifier, executorSchema),
+    status: z.enum(["active", "paused", "cancelled", "completed", "expired"]),
+    nextAt: z.number().finite().nullable(), createdAt: timestamp,
+}).strict();
+const roundSchema = z.object({
+    id: z.string().uuid(), taskId: z.string().uuid(), scheduledAt: z.number().finite(),
+    status: z.enum(["running", "succeeded", "failed", "interrupted", "skipped", "cancelled", "timed_out", "waiting_input"]),
+    createdAt: timestamp, finishedAt: timestamp.nullable(), error: z.string().nullable(), skippedCount: z.number().int().nonnegative(),
+    steps: z.number().int().nonnegative(), coordinatorStartedAt: timestamp.nullable(), summary: z.string().nullable(),
+    waitedMs: z.number().finite().nonnegative(),
+    questions: z.array(questionSchema.extend({
+        id: z.string().uuid(), createdAt: timestamp, expiresAt: timestamp, sessionExpiresAt: timestamp.nullable(),
+        reply: z.object({ requestKey: identifier, answer: z.string().min(1).max(16000), receivedAt: timestamp }).strict().nullable(),
+    })).max(20),
+    nodes: z.array(z.object({
+        id: z.string().uuid(), definition: nodeSchema,
+        status: z.enum(["pending", "running", "awaiting_review", "succeeded", "failed", "blocked", "interrupted"]),
+        workspace: z.string().nullable(), inputFiles: z.array(z.string()), resultFile: z.string().nullable(), result: z.string().nullable(), acceptance: z.string().nullable(),
+        turns: z.array(z.object({ prompt: z.string(), output: z.string(), stopReason: z.string().nullable() }).strict()),
+        error: z.string().nullable(), sessionId: z.string().nullable(), startedAt: timestamp.nullable(), eventCount: z.number().int().nonnegative(),
+    }).strict()).min(1).max(20),
+}).strict();
+export class StorageError extends Error {
+}
+/** Task definitions and rounds share one transactional store. */
+export class TaskStore {
+    db;
+    closed = false;
+    get healthy() { return !this.closed; }
+    constructor(directory) {
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        this.db = new DatabaseSync(join(directory, "tasks.sqlite"));
+        try {
+            const tables = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all();
+            if (tables.length) {
+                this.db.prepare("SELECT seq,id,request_key,data FROM definitions LIMIT 0").all();
+                this.db.prepare("SELECT seq,id,task_id,scheduled_at,data FROM rounds LIMIT 0").all();
+            }
+            this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA foreign_keys=ON");
+            if (!tables.length)
+                this.db.exec(`BEGIN IMMEDIATE;
+        CREATE TABLE definitions(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, request_key TEXT UNIQUE NOT NULL, data TEXT NOT NULL);
+        CREATE TABLE rounds(seq INTEGER PRIMARY KEY, id TEXT UNIQUE NOT NULL, task_id TEXT NOT NULL REFERENCES definitions(id),
+          scheduled_at REAL NOT NULL, data TEXT NOT NULL, UNIQUE(task_id,scheduled_at));
+        COMMIT;`);
+        }
+        catch (error) {
+            this.db.close();
+            throw error;
+        }
+    }
+    check() { if (this.closed)
+        throw new StorageError("Task storage closed"); }
+    definitions() {
+        this.check();
+        return this.db.prepare("SELECT data FROM definitions ORDER BY seq").all().map(row => definitionSchema.parse(JSON.parse(String(row["data"]))));
+    }
+    rounds(taskId) {
+        this.check();
+        const rows = taskId ? this.db.prepare("SELECT data FROM rounds WHERE task_id=? ORDER BY seq").all(taskId)
+            : this.db.prepare("SELECT data FROM rounds ORDER BY seq").all();
+        return rows.map(row => roundSchema.parse(JSON.parse(String(row["data"]))));
+    }
+    activeRounds(taskId) {
+        this.check();
+        const rows = taskId
+            ? this.db.prepare("SELECT data FROM rounds WHERE task_id=? AND json_extract(data,'$.status') IN ('running','waiting_input')").all(taskId)
+            : this.db.prepare("SELECT data FROM rounds WHERE json_extract(data,'$.status') IN ('running','waiting_input')").all();
+        return rows.map(row => roundSchema.parse(JSON.parse(String(row["data"]))));
+    }
+    get(id) {
+        this.check();
+        const row = this.db.prepare("SELECT data FROM definitions WHERE id=?").get(id);
+        if (!row)
+            throw new Error("Task not found");
+        return definitionSchema.parse(JSON.parse(String(row["data"])));
+    }
+    run(id) {
+        this.check();
+        const row = this.db.prepare("SELECT data FROM rounds WHERE id=?").get(id);
+        if (!row)
+            throw new Error("Task run not found");
+        return roundSchema.parse(JSON.parse(String(row["data"])));
+    }
+    /** The service supplies all policy; the store commits a cursor and round atomically. */
+    commit(definition, round) {
+        this.check();
+        if (definition)
+            definitionSchema.parse(definition);
+        if (round)
+            roundSchema.parse(round);
+        try {
+            this.db.exec("BEGIN IMMEDIATE");
+            if (definition)
+                this.db.prepare(`INSERT INTO definitions(id,request_key,data) VALUES(?,?,?)
+        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(definition.id, definition.input.requestKey, JSON.stringify(definition));
+            if (round)
+                this.db.prepare(`INSERT INTO rounds(id,task_id,scheduled_at,data) VALUES(?,?,?,?)
+        ON CONFLICT(id) DO UPDATE SET data=excluded.data`).run(round.id, round.taskId, round.scheduledAt, JSON.stringify(round));
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            try {
+                this.db.exec("ROLLBACK");
+            }
+            catch { }
+            this.close();
+            throw new StorageError("Task commit failed", { cause: error });
+        }
+    }
+    close() { if (!this.closed) {
+        this.closed = true;
+        this.db.close();
+    } }
+}
+//# sourceMappingURL=task-storage.js.map