doer-agent 0.5.9 → 0.6.1

package/dist/codex-app-server-manager.js

@@ -0,0 +1,117 @@
+import { buildAgentSettingsEnvPatch, readAgentModelInstructions, resolveAgentModelInstructionsFilePath, } from "./agent-settings.js";
+import { buildDaemonMcpConfigArgs } from "./agent-codex-cli.js";
+import { CodexAppServerClient } from "./codex-app-server-client.js";
+function toTomlStringLiteral(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function buildConfigArg(key, tomlValue) {
+    return ["--config", `${key}=${tomlValue}`];
+}
+function buildFeatureArg(enabled, name) {
+    return [enabled ? "--enable" : "--disable", name];
+}
+async function buildCodexAppServerArgs(args) {
+    const configArgs = [
+        ...buildConfigArg("model", toTomlStringLiteral(args.settings.codex.model)),
+        ...buildConfigArg("personality", toTomlStringLiteral(args.settings.general.personality)),
+        ...buildConfigArg("approval_policy", toTomlStringLiteral("never")),
+        ...buildConfigArg("sandbox_mode", toTomlStringLiteral("danger-full-access")),
+    ];
+    const customInstructions = await readAgentModelInstructions(args.workspaceRoot);
+    if (customInstructions) {
+        configArgs.push(...buildConfigArg("model_instructions_file", toTomlStringLiteral(resolveAgentModelInstructionsFilePath(args.workspaceRoot))));
+    }
+    return [
+        "app-server",
+        ...configArgs,
+        ...buildDaemonMcpConfigArgs({
+            agentProjectDir: args.agentProjectDir,
+            workspaceRoot: args.workspaceRoot,
+        }),
+        ...buildFeatureArg(args.settings.codex.computerUseEnabled, "computer_use"),
+        ...buildFeatureArg(args.settings.codex.browserUseEnabled, "browser_use"),
+        "--listen",
+        "stdio://",
+    ];
+}
+async function buildCodexAppServerEnv(args) {
+    return {
+        ...process.env,
+        ...buildAgentSettingsEnvPatch(args.settings),
+        CODEX_HOME: args.resolveCodexHomePath(),
+    };
+}
+export function createCodexAppServerManager(args) {
+    let client = null;
+    let createPromise = null;
+    let generation = 0;
+    const createClient = async () => {
+        const settings = await args.readAgentSettingsConfig({ workspaceRoot: args.workspaceRoot });
+        const appServerArgs = await buildCodexAppServerArgs({
+            workspaceRoot: args.workspaceRoot,
+            agentProjectDir: args.agentProjectDir,
+            settings,
+        });
+        const env = await buildCodexAppServerEnv({
+            workspaceRoot: args.workspaceRoot,
+            resolveCodexHomePath: args.resolveCodexHomePath,
+            settings,
+        });
+        args.onLog?.(`starting codex app-server model=${settings.codex.model} personality=${settings.general.personality} computerUse=${settings.codex.computerUseEnabled} browserUse=${settings.codex.browserUseEnabled}`);
+        return new CodexAppServerClient({
+            cwd: args.workspaceRoot,
+            args: appServerArgs,
+            env,
+            onLog: args.onLog,
+            onNotification: args.onNotification,
+        });
+    };
+    const getClient = async () => {
+        if (client) {
+            return client;
+        }
+        if (!createPromise) {
+            createPromise = createClient();
+        }
+        const activeCreatePromise = createPromise;
+        const requestedGeneration = generation;
+        try {
+            const createdClient = await activeCreatePromise;
+            if (requestedGeneration !== generation) {
+                await createdClient.stop();
+                return await getClient();
+            }
+            client = createdClient;
+            return client;
+        }
+        finally {
+            if (createPromise === activeCreatePromise) {
+                createPromise = null;
+            }
+        }
+    };
+    return {
+        async request(method, params) {
+            const activeClient = await getClient();
+            return await activeClient.request(method, params);
+        },
+        async restart(reason) {
+            generation += 1;
+            const activeClient = client;
+            client = null;
+            createPromise = null;
+            if (!activeClient) {
+                args.onLog?.(`codex app-server restart requested before start reason=${reason}`);
+                return;
+            }
+            args.onLog?.(`restarting codex app-server reason=${reason}`);
+            await activeClient.stop();
+        },
+        async stop() {
+            const activeClient = client;
+            client = null;
+            createPromise = null;
+            await activeClient?.stop();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",
@@ -26,14 +26,11 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "@openai/codex-sdk": "^0.128.0",
-    "mysql2": "^3.22.2",
     "nats": "^2.29.3",
-    "pg": "^8.16.3",
     "tar": "^7.5.13"
   },
   "devDependencies": {
     "@types/node": "^20",
-    "@types/pg": "^8.15.5",
     "tsx": "^4.21.0",
     "typescript": "^5"
   }

package/dist/agent-run-execution.js

@@ -1,39 +0,0 @@
-import path from "node:path";
-import { mkdir } from "node:fs/promises";
-export async function prepareCommandExecution(args) {
-    const shellPath = args.resolveShellPath();
-    const taskWorkspace = args.resolveTaskWorkspace(args.cwd);
-    const codexHome = args.resolveCodexHomePath();
-    await mkdir(codexHome, { recursive: true });
-    const codexAuth = await args.prepareCodexAuthBundle(args.codexAuthBundle);
-    const localAgentSettings = await args.readAgentSettingsConfig({ workspaceRoot: args.resolveWorkspaceRoot() });
-    const baseTaskEnvPatch = {
-        CODEX_HOME: codexHome,
-        DOER_USER_ID: args.userId,
-        DOER_AGENT_TASK_ID: args.taskId,
-        ...args.buildAgentSettingsEnvPatch(localAgentSettings),
-        ...args.runtimeEnvPatch,
-        ...(codexAuth?.envPatch ?? {}),
-        WORKSPACE: taskWorkspace,
-    };
-    const taskGitEnv = await args.prepareTaskGitEnv({
-        cwd: taskWorkspace,
-        baseEnvPatch: baseTaskEnvPatch,
-    });
-    const runtimeBinPath = path.join(args.agentProjectDir, "runtime/bin");
-    const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
-    return {
-        shellPath,
-        taskWorkspace,
-        taskPath,
-        env: {
-            ...process.env,
-            ...baseTaskEnvPatch,
-            ...taskGitEnv.envPatch,
-            PATH: taskPath,
-        },
-        taskGitMeta: taskGitEnv.meta ?? {},
-        codexAuthMeta: codexAuth?.meta ?? { codexAuthSynced: false },
-        codexAuthCleanup: codexAuth?.cleanup ?? (async () => { }),
-    };
-}

package/dist/agent-run-lifecycle.js

@@ -1,67 +0,0 @@
-export function createPendingRunSessionTracker(args) {
-    let closed = false;
-    let timer = null;
-    const stop = () => {
-        closed = true;
-        if (timer) {
-            clearInterval(timer);
-            timer = null;
-        }
-    };
-    const poll = async () => {
-        if (closed || args.task.sessionId) {
-            stop();
-            return;
-        }
-        const detected = await args.detectPendingRunSession().catch(() => null);
-        if (!detected) {
-            return;
-        }
-        await args.updateRunSessionMetadata(detected).catch(() => undefined);
-        if (args.task.sessionId) {
-            stop();
-        }
-    };
-    const start = () => {
-        if (closed || args.task.sessionId || timer) {
-            return;
-        }
-        timer = setInterval(() => {
-            void poll();
-        }, args.pollIntervalMs ?? 1000);
-    };
-    return { poll, start, stop };
-}
-export function attachManagedRunProcessLifecycle(args) {
-    args.child.once("error", (error) => {
-        args.stopPendingSessionPoll();
-        const message = error instanceof Error ? error.message : String(error);
-        args.task.status = "failed";
-        args.task.error = message;
-        args.task.finishedAt = args.formatTimestamp();
-        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
-        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
-        void args.removeRunTask(args.task.id).catch(() => undefined);
-        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
-        void args.codexAuthCleanup().catch(() => undefined);
-        args.writeRunStatus(args.task.id, `failed error=${message}`);
-    });
-    args.child.once("close", async (code, signal) => {
-        args.stopPendingSessionPoll();
-        const latest = await args.getStoredRun(args.task.id).catch(() => null);
-        if (latest?.cancelRequested) {
-            args.task.cancelRequested = true;
-        }
-        args.task.resultExitCode = typeof code === "number" ? code : null;
-        args.task.resultSignal = signal;
-        args.task.finishedAt = args.formatTimestamp();
-        args.task.status = args.task.cancelRequested ? "canceled" : (args.task.resultExitCode ?? 1) === 0 ? "completed" : "failed";
-        args.task.error = args.task.status === "failed" ? `Command exited with code ${args.task.resultExitCode ?? "null"}` : null;
-        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task });
-        args.publishImmediateRunEvent({ nc: args.nc, userId: args.task.userId, task: args.task, type: "run.finished" });
-        void args.removeRunTask(args.task.id).catch(() => undefined);
-        void args.releaseRunStartSlot({ runId: args.task.id, sessionId: args.task.sessionId }).catch(() => undefined);
-        void args.codexAuthCleanup().catch(() => undefined);
-        args.writeRunStatus(args.task.id, `completed status=${args.task.status} exitCode=${args.task.resultExitCode ?? "null"} signal=${args.task.resultSignal ?? "null"}`);
-    });
-}

package/dist/agent-run-rpc.js

@@ -1,93 +0,0 @@
-import { StringCodec } from "nats";
-const runRpcCodec = StringCodec();
-export function normalizeRunRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    if (!requestId) {
-        throw new Error("missing requestId");
-    }
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    if (!requestAgentId || requestAgentId !== args.agentId) {
-        throw new Error("agent id mismatch");
-    }
-    const actionRaw = typeof args.request.action === "string" ? args.request.action.trim() : "";
-    const action = actionRaw === "cancel" || actionRaw === "get" || actionRaw === "list" ? actionRaw : "start";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    if (!responseSubject) {
-        throw new Error("missing responseSubject");
-    }
-    const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
-    const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
-    const imagePaths = args.normalizeImagePaths(args.request.imagePaths);
-    const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
-    const model = args.normalizeModel(args.request.model);
-    if (action === "start" && !prompt) {
-        throw new Error("missing prompt");
-    }
-    if ((action === "get" || action === "cancel") && !runId) {
-        throw new Error("missing runId");
-    }
-    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
-    const sinceSeqRaw = Number(args.request.sinceSeq);
-    const sinceSeq = Number.isInteger(sinceSeqRaw) && sinceSeqRaw >= 0 ? sinceSeqRaw : null;
-    const limitRaw = Number(args.request.limit);
-    const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(Math.floor(limitRaw), 200)) : 50;
-    return {
-        requestId,
-        action,
-        runId,
-        prompt,
-        imagePaths,
-        sessionId,
-        model,
-        cwd,
-        responseSubject,
-        sinceSeq,
-        limit,
-        runtimeEnvPatch: args.normalizeEnvPatch(args.request.runtimeEnvPatch),
-        codexAuthBundle: args.normalizeCodexAuthBundle(args.request.codexAuth),
-    };
-}
-export function publishRunRpcResponse(args) {
-    args.nc.publish(args.responseSubject, runRpcCodec.encode(JSON.stringify(args.payload)));
-}
-export async function handleNonStartRunRpc(args) {
-    const { request } = args;
-    if (request.action === "list") {
-        const merged = (await args.listPersistedRunTasks())
-            .map((task) => args.cloneRunTask(task))
-            .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
-            .slice(0, request.limit);
-        publishRunRpcResponse({
-            nc: args.nc,
-            responseSubject: request.responseSubject,
-            payload: { requestId: request.requestId, ok: true, tasks: merged },
-        });
-        return;
-    }
-    const stored = request.runId ? await args.getStoredRun(request.runId) : null;
-    if (!stored || stored.agentId !== args.agentId || stored.userId !== args.userId) {
-        throw new Error("Run not found");
-    }
-    if (request.action === "cancel") {
-        if (stored.processPid === null) {
-            throw new Error("Run pid not found");
-        }
-        stored.cancelRequested = true;
-        stored.updatedAt = args.formatTimestamp();
-        await args.persistRunTask(stored);
-        args.publishImmediateRunEvent(stored);
-        args.writeRunStatus(stored.id, `cancel requested pid=${stored.processPid}`);
-        args.sendSignalToPid(stored.processPid, "SIGINT");
-        publishRunRpcResponse({
-            nc: args.nc,
-            responseSubject: request.responseSubject,
-            payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored) },
-        });
-        return;
-    }
-    publishRunRpcResponse({
-        nc: args.nc,
-        responseSubject: request.responseSubject,
-        payload: { requestId: request.requestId, ok: true, task: args.cloneRunTask(stored, request.sinceSeq) },
-    });
-}

package/dist/agent-run-state.js

@@ -1,287 +0,0 @@
-import { mkdir, open, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { StringCodec } from "nats";
-const runEventsCodec = StringCodec();
-async function resolveRunsDir(workspaceRoot) {
-    const dir = path.join(workspaceRoot, ".doer-agent", "runs");
-    await mkdir(dir, { recursive: true });
-    return dir;
-}
-function sanitizeRunLockSegment(value) {
-    return value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "lock";
-}
-async function resolveRunLocksDir(workspaceRoot) {
-    const dir = path.join(await resolveRunsDir(workspaceRoot), "locks");
-    await mkdir(dir, { recursive: true });
-    return dir;
-}
-async function resolveRunStartLockPath(args) {
-    const dir = await resolveRunLocksDir(args.workspaceRoot);
-    if (typeof args.sessionId === "string" && args.sessionId.trim()) {
-        return path.join(dir, `session__${sanitizeRunLockSegment(args.sessionId)}.lock`);
-    }
-    return path.join(dir, "pending_new_session.lock");
-}
-function normalizePersistedRunTask(value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const record = value;
-    const id = typeof record.runId === "string" && record.runId.trim()
-        ? record.runId.trim()
-        : typeof record.id === "string" && record.id.trim()
-            ? record.id.trim()
-            : "";
-    const userId = typeof record.userId === "string" ? record.userId : "";
-    const agentId = typeof record.agentId === "string" ? record.agentId : "";
-    const status = record.status;
-    if (!id || !userId || !agentId || !["queued", "running", "completed", "failed", "canceled"].includes(String(status))) {
-        return null;
-    }
-    return {
-        id,
-        userId,
-        agentId,
-        processPid: typeof record.processPid === "number" ? record.processPid : null,
-        sessionId: typeof record.sessionId === "string" && record.sessionId.trim() ? record.sessionId.trim() : null,
-        sessionFilePath: typeof record.sessionFilePath === "string" && record.sessionFilePath.trim() ? record.sessionFilePath.trim() : null,
-        status: status,
-        cancelRequested: Boolean(record.cancelRequested),
-        resultExitCode: typeof record.resultExitCode === "number" ? record.resultExitCode : null,
-        resultSignal: typeof record.resultSignal === "string" && record.resultSignal.trim() ? record.resultSignal.trim() : null,
-        error: typeof record.error === "string" && record.error.trim() ? record.error : null,
-        createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
-        updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : "",
-        startedAt: typeof record.startedAt === "string" && record.startedAt.trim() ? record.startedAt : null,
-        finishedAt: typeof record.finishedAt === "string" && record.finishedAt.trim() ? record.finishedAt : null,
-    };
-}
-function buildImmediateRunEvent(task, type) {
-    return {
-        type,
-        agentId: task.agentId,
-        sessionId: task.sessionId,
-        filePath: task.sessionFilePath,
-        runId: task.id,
-        updatedAt: task.updatedAt,
-        status: task.status,
-        cancelRequested: task.cancelRequested,
-        resultExitCode: task.resultExitCode,
-        resultSignal: task.resultSignal,
-        error: task.error,
-        finishedAt: task.finishedAt,
-    };
-}
-function isPidAlive(pid) {
-    if (!Number.isInteger(pid) || (pid ?? 0) <= 0) {
-        return false;
-    }
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        const code = error?.code;
-        return code === "EPERM";
-    }
-}
-async function removePathIfStale(pathToRemove, pid) {
-    if (isPidAlive(pid)) {
-        return;
-    }
-    await rm(pathToRemove, { recursive: true, force: true }).catch(() => undefined);
-}
-export async function pruneStaleRunsDir(workspaceRoot) {
-    const dir = await resolveRunsDir(workspaceRoot);
-    const names = await readdir(dir).catch(() => []);
-    for (const name of names) {
-        const entryPath = path.join(dir, name);
-        if (name === "locks") {
-            const lockNames = await readdir(entryPath).catch(() => []);
-            for (const lockName of lockNames) {
-                const lockPath = path.join(entryPath, lockName);
-                const contents = await readFile(lockPath, "utf8").catch(() => null);
-                if (!contents) {
-                    await rm(lockPath, { recursive: true, force: true }).catch(() => undefined);
-                    continue;
-                }
-                let pid = null;
-                try {
-                    const parsed = JSON.parse(contents);
-                    pid = typeof parsed.pid === "number" && Number.isInteger(parsed.pid) && parsed.pid > 0 ? parsed.pid : null;
-                }
-                catch {
-                    pid = null;
-                }
-                await removePathIfStale(lockPath, pid);
-            }
-            continue;
-        }
-        if (!name.endsWith(".json")) {
-            continue;
-        }
-        const contents = await readFile(entryPath, "utf8").catch(() => null);
-        if (!contents) {
-            await rm(entryPath, { recursive: true, force: true }).catch(() => undefined);
-            continue;
-        }
-        let task = null;
-        try {
-            task = normalizePersistedRunTask(JSON.parse(contents));
-        }
-        catch {
-            task = null;
-        }
-        await removePathIfStale(entryPath, task?.processPid ?? null);
-    }
-}
-export async function persistRunTask(workspaceRoot, task) {
-    const dir = await resolveRunsDir(workspaceRoot);
-    const payload = {
-        runId: task.id,
-        agentId: task.agentId,
-        userId: task.userId,
-        processPid: task.processPid,
-        sessionId: task.sessionId,
-        sessionFilePath: task.sessionFilePath,
-        status: task.status,
-        cancelRequested: task.cancelRequested,
-        resultExitCode: task.resultExitCode,
-        resultSignal: task.resultSignal,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-        startedAt: task.startedAt,
-        finishedAt: task.finishedAt,
-        error: task.error,
-    };
-    await writeFile(path.join(dir, `${task.id}.json`), `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-export async function removeRunTask(workspaceRoot, runId) {
-    const dir = await resolveRunsDir(workspaceRoot);
-    await unlink(path.join(dir, `${runId}.json`)).catch(() => undefined);
-}
-export async function claimRunStartSlot(args) {
-    const lockPath = await resolveRunStartLockPath(args);
-    try {
-        const handle = await open(lockPath, "wx");
-        try {
-            const payload = {
-                runId: args.runId,
-                sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
-                pid: process.pid,
-                createdAt: args.formatTimestamp(),
-            };
-            await handle.writeFile(`${JSON.stringify(payload, null, 2)}\n`, "utf8");
-        }
-        finally {
-            await handle.close().catch(() => undefined);
-        }
-    }
-    catch (error) {
-        if (error?.code === "EEXIST") {
-            const lockContents = await readFile(lockPath, "utf8").catch(() => "");
-            const existingRunId = (() => {
-                try {
-                    const parsed = JSON.parse(lockContents);
-                    return typeof parsed.runId === "string" && parsed.runId.trim() ? parsed.runId.trim() : null;
-                }
-                catch {
-                    return null;
-                }
-            })();
-            throw new Error(existingRunId ? `Another run is already active: ${existingRunId}` : "Another run is already active");
-        }
-        throw error;
-    }
-}
-export async function updateRunStartSlotSession(args) {
-    const nextSessionId = args.sessionId.trim();
-    if (!nextSessionId) {
-        return;
-    }
-    const previousSessionId = typeof args.previousSessionId === "string" && args.previousSessionId.trim() ? args.previousSessionId.trim() : null;
-    if (previousSessionId === nextSessionId) {
-        return;
-    }
-    const currentPath = await resolveRunStartLockPath({
-        workspaceRoot: args.workspaceRoot,
-        runId: args.runId,
-        sessionId: previousSessionId,
-    });
-    const nextPath = await resolveRunStartLockPath({
-        workspaceRoot: args.workspaceRoot,
-        runId: args.runId,
-        sessionId: nextSessionId,
-    });
-    if (currentPath === nextPath) {
-        return;
-    }
-    try {
-        await rename(currentPath, nextPath);
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ENOENT") {
-            return;
-        }
-        if (code === "EEXIST") {
-            throw new Error(`Another run is already active for session: ${nextSessionId}`);
-        }
-        throw error;
-    }
-    const payload = {
-        runId: args.runId,
-        sessionId: nextSessionId,
-        pid: process.pid,
-        createdAt: args.formatTimestamp(),
-    };
-    await writeFile(nextPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
-}
-export async function releaseRunStartSlot(args) {
-    const paths = new Set();
-    paths.add(await resolveRunStartLockPath({ workspaceRoot: args.workspaceRoot, runId: args.runId, sessionId: args.sessionId ?? null }));
-    paths.add(await resolveRunStartLockPath({ workspaceRoot: args.workspaceRoot, runId: args.runId, sessionId: null }));
-    for (const lockPath of paths) {
-        await unlink(lockPath).catch(() => undefined);
-    }
-}
-export function cloneRunTask(task, _sinceSeq) {
-    return { ...task };
-}
-export function publishImmediateRunEvent(args) {
-    args.nc.publish(args.buildRunEventsSubject(args.userId, args.task.agentId), runEventsCodec.encode(JSON.stringify(buildImmediateRunEvent(args.task, args.type ?? "run.changed"))));
-}
-export async function listPersistedRunTasks(workspaceRoot) {
-    const dir = await resolveRunsDir(workspaceRoot);
-    const names = await readdir(dir).catch(() => []);
-    const tasks = await Promise.all(names
-        .filter((name) => name.endsWith(".json"))
-        .map(async (name) => {
-        const raw = await readFile(path.join(dir, name), "utf8").catch(() => null);
-        if (!raw) {
-            return null;
-        }
-        try {
-            return normalizePersistedRunTask(JSON.parse(raw));
-        }
-        catch {
-            return null;
-        }
-    }));
-    return tasks.filter((task) => task !== null);
-}
-export async function getStoredRun(workspaceRoot, runId) {
-    const persisted = await readFile(path.join(await resolveRunsDir(workspaceRoot), `${runId}.json`), "utf8").catch(() => null);
-    if (persisted) {
-        try {
-            const parsed = normalizePersistedRunTask(JSON.parse(persisted));
-            if (parsed) {
-                return parsed;
-            }
-        }
-        catch {
-            // Ignore malformed persisted state.
-        }
-    }
-    return null;
-}

package/dist/agent-runtime-utils.test.js

@@ -1,38 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import path from "node:path";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { filterValidRunImagePaths } from "./agent-runtime-utils.js";
-const invalidTinyPngBase64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aK1cAAAAASUVORK5CYII=";
-function buildValidTinyPng() {
-    const bytes = Buffer.from(invalidTinyPngBase64, "base64");
-    bytes.writeUInt32BE(0xefa2a75b, 0x34);
-    return bytes;
-}
-test("filterValidRunImagePaths drops PNGs with CRC mismatches", async () => {
-    const workspaceRoot = await mkdtemp(path.join(os.tmpdir(), "doer-agent-image-filter-"));
-    try {
-        const invalidPngPath = path.join(workspaceRoot, "bad.png");
-        const validPngPath = path.join(workspaceRoot, "good.png");
-        const validJpgPath = path.join(workspaceRoot, "photo.jpg");
-        await writeFile(invalidPngPath, Buffer.from(invalidTinyPngBase64, "base64"));
-        await writeFile(validPngPath, buildValidTinyPng());
-        await writeFile(validJpgPath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
-        const invalid = [];
-        const result = await filterValidRunImagePaths({
-            workspaceRoot,
-            imagePaths: ["bad.png", "good.png", "photo.jpg"],
-            onInvalidImage: (imagePath, reason) => {
-                invalid.push({ imagePath, reason });
-            },
-        });
-        assert.deepEqual(result, ["good.png", "photo.jpg"]);
-        assert.equal(invalid.length, 1);
-        assert.equal(invalid[0]?.imagePath, "bad.png");
-        assert.match(invalid[0]?.reason ?? "", /CRC mismatch/i);
-    }
-    finally {
-        await rm(workspaceRoot, { recursive: true, force: true });
-    }
-});