doer-agent 0.2.5 → 0.2.7

package/dist/agent.js

@@ -1,6 +1,6 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, statSync, watch } from "node:fs";
-import { chmod, mkdir, open, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { AckPolicy, connect, DeliverPolicy, JSONCodec, RetentionPolicy, StorageType, StringCodec } from "nats";
@@ -9,17 +9,13 @@ const AGENT_MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const AGENT_PROJECT_DIR = path.join(AGENT_MODULE_DIR, "..");
 const AGENT_PACKAGE_JSON_PATH = path.join(AGENT_PROJECT_DIR, "package.json");
 let activeTaskLogContext = null;
-const activeTaskCancelRequests = new Map();
 let workspaceRootOverride = null;
 const fsRpcCodec = StringCodec();
-const shellRpcCodec = StringCodec();
 const runRpcCodec = StringCodec();
 const sessionRpcCodec = StringCodec();
-const codexRpcCodec = StringCodec();
 const codexAuthRpcCodec = StringCodec();
 const settingsRpcCodec = StringCodec();
 const gitRpcCodec = StringCodec();
-const activeRuns = new Map();
 const retainedRuns = new Map();
 const activeSessionWatchers = new Map();
 const sessionLineIndexCache = new Map();
@@ -35,9 +31,6 @@ function buildAgentRunRpcSubject(userId, agentId) {
 function buildAgentSessionRpcSubject(userId, agentId) {
     return `doer.agent.session.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
-function buildAgentCodexRpcSubject(userId, agentId) {
-    return `doer.agent.codex.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
 function buildAgentCodexAuthRpcSubject(userId, agentId) {
     return `doer.agent.codex.auth.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
@@ -421,9 +414,11 @@ function normalizeRunRpcRequest(args) {
         throw new Error("missing responseSubject");
     }
     const runId = typeof args.request.runId === "string" && args.request.runId.trim() ? args.request.runId.trim() : null;
-    const command = typeof args.request.command === "string" && args.request.command.trim() ? args.request.command.trim() : null;
-    if (action === "start" && !command) {
-        throw new Error("missing command");
+    const prompt = typeof args.request.prompt === "string" && args.request.prompt.trim() ? args.request.prompt.trim() : null;
+    const sessionId = typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null;
+    const model = normalizeCodexModel(args.request.model);
+    if (action === "start" && !prompt) {
+        throw new Error("missing prompt");
     }
     if ((action === "get" || action === "cancel") && !runId) {
         throw new Error("missing runId");
@@ -437,7 +432,9 @@ function normalizeRunRpcRequest(args) {
         requestId,
         action,
         runId,
-        command,
+        prompt,
+        sessionId,
+        model,
         cwd,
         responseSubject,
         sinceSeq,
@@ -466,10 +463,13 @@ async function persistRunTask(task) {
         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,
@@ -482,6 +482,99 @@ async function removeRunTask(runId) {
     const dir = await resolveRunsDir();
     await unlink(path.join(dir, `${runId}.json`)).catch(() => undefined);
 }
+function sanitizeRunLockSegment(value) {
+    return value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "lock";
+}
+async function resolveRunLocksDir() {
+    const dir = path.join(await resolveRunsDir(), "locks");
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+async function resolveRunStartLockPath(args) {
+    const dir = await resolveRunLocksDir();
+    if (typeof args.sessionId === "string" && args.sessionId.trim()) {
+        return path.join(dir, `session__${sanitizeRunLockSegment(args.sessionId)}.lock`);
+    }
+    return path.join(dir, `run__${sanitizeRunLockSegment(args.runId)}.lock`);
+}
+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: formatLocalTimestamp(),
+            };
+            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;
+    }
+}
+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({ runId: args.runId, sessionId: previousSessionId });
+    const nextPath = await resolveRunStartLockPath({ runId: args.runId, sessionId: nextSessionId });
+    if (currentPath === nextPath) {
+        return;
+    }
+    try {
+        await rename(currentPath, nextPath);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+            // Lock may already be released; nothing to migrate.
+            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: formatLocalTimestamp(),
+    };
+    await writeFile(nextPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+async function releaseRunStartSlot(args) {
+    const paths = new Set();
+    paths.add(await resolveRunStartLockPath({ runId: args.runId, sessionId: args.sessionId ?? null }));
+    paths.add(await resolveRunStartLockPath({ runId: args.runId, sessionId: null }));
+    for (const lockPath of paths) {
+        await unlink(lockPath).catch(() => undefined);
+    }
+}
 function resolveAgentSettingsDir() {
     const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
     return path.join(workspaceRoot, ".doer-agent");
@@ -902,6 +995,7 @@ function extractCodexSessionMetadata(value) {
 }
 async function updateRunSessionMetadata(task, metadata) {
     let changed = false;
+    const previousSessionId = task.sessionId;
     if (!task.sessionId && typeof metadata.sessionId === "string" && metadata.sessionId.trim()) {
         task.sessionId = metadata.sessionId.trim();
         changed = true;
@@ -915,14 +1009,82 @@ async function updateRunSessionMetadata(task, metadata) {
     }
     task.updatedAt = formatLocalTimestamp();
     await persistRunTask(task).catch(() => undefined);
+    if (!previousSessionId && task.sessionId) {
+        await updateRunStartSlotSession({
+            runId: task.id,
+            previousSessionId,
+            sessionId: task.sessionId,
+        }).catch(() => undefined);
+    }
 }
 function persistRetainedRun(task) {
     retainedRuns.set(task.id, cloneRunTask(task));
 }
-function getStoredRun(runId) {
-    const active = activeRuns.get(runId);
-    if (active) {
-        return active.task;
+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,
+    };
+}
+async function listPersistedRunTasks() {
+    const dir = await resolveRunsDir();
+    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);
+}
+async function getStoredRun(runId) {
+    const persisted = await readFile(path.join(await resolveRunsDir(), `${runId}.json`), "utf8").catch(() => null);
+    if (persisted) {
+        try {
+            const parsed = normalizePersistedRunTask(JSON.parse(persisted));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // Ignore malformed persisted state and fall back to retained memory.
+        }
     }
     return retainedRuns.get(runId) ?? null;
 }
@@ -933,11 +1095,8 @@ async function startManagedRun(args) {
         taskId: args.runId,
         codexAuthBundle: args.codexAuthBundle,
     });
-    const child = spawnPreparedCommand({
-        kind: "shell",
-        command: args.command,
-        patch: null,
-        shellPath: prepared.shellPath,
+    const child = spawnManagedCodexCommand({
+        codexArgs: args.codexArgs,
         taskWorkspace: prepared.taskWorkspace,
         env: prepared.env,
         agentToken: args.agentToken,
@@ -947,6 +1106,7 @@ async function startManagedRun(args) {
         id: args.runId,
         userId: args.userId,
         agentId: args.agentId,
+        processPid: typeof child.pid === "number" ? child.pid : null,
         sessionId: typeof args.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : null,
         sessionFilePath: null,
         status: "running",
@@ -959,17 +1119,6 @@ async function startManagedRun(args) {
         startedAt: now,
         finishedAt: null,
     };
-    const cancellation = createManagedCancellation(child);
-    const requestCancel = () => {
-        if (task.status === "completed" || task.status === "failed" || task.status === "canceled") {
-            return;
-        }
-        task.cancelRequested = true;
-        task.updatedAt = formatLocalTimestamp();
-        void persistRunTask(task).catch(() => undefined);
-        writeRunStatus(task.id, "cancel requested");
-        cancellation.requestCancel();
-    };
     let stdoutBuffer = "";
     const recordChunk = (stream, chunk) => {
         writeRunStream(task.id, stream, chunk);
@@ -998,31 +1147,33 @@ async function startManagedRun(args) {
         task.error = message;
         task.finishedAt = formatLocalTimestamp();
         persistRetainedRun(task);
-        activeRuns.delete(task.id);
         void removeRunTask(task.id).catch(() => undefined);
+        void releaseRunStartSlot({ runId: task.id, sessionId: task.sessionId }).catch(() => undefined);
         void prepared.codexAuthCleanup().catch(() => undefined);
         writeRunStatus(task.id, `failed error=${message}`);
     });
-    child.once("close", (code, signal) => {
-        cancellation.clear();
+    child.once("close", async (code, signal) => {
         if (stdoutBuffer.trim() && (!task.sessionId || !task.sessionFilePath)) {
             const metadata = extractCodexSessionMetadata(stdoutBuffer.trim());
             if (metadata.sessionId || metadata.sessionFilePath) {
                 void updateRunSessionMetadata(task, metadata);
             }
         }
+        const latest = await getStoredRun(task.id).catch(() => null);
+        if (latest?.cancelRequested) {
+            task.cancelRequested = true;
+        }
         task.resultExitCode = typeof code === "number" ? code : null;
         task.resultSignal = signal;
         task.finishedAt = formatLocalTimestamp();
         task.status = task.cancelRequested ? "canceled" : (task.resultExitCode ?? 1) === 0 ? "completed" : "failed";
         task.error = task.status === "failed" ? `Command exited with code ${task.resultExitCode ?? "null"}` : null;
         persistRetainedRun(task);
-        activeRuns.delete(task.id);
         void removeRunTask(task.id).catch(() => undefined);
+        void releaseRunStartSlot({ runId: task.id, sessionId: task.sessionId }).catch(() => undefined);
         void prepared.codexAuthCleanup().catch(() => undefined);
         writeRunStatus(task.id, `completed status=${task.status} exitCode=${task.resultExitCode ?? "null"} signal=${task.resultSignal ?? "null"}`);
     });
-    activeRuns.set(task.id, { task, child, requestCancel });
     persistRetainedRun(task);
     void persistRunTask(task).catch(() => undefined);
     writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
@@ -1038,45 +1189,17 @@ function normalizeCodexModel(value) {
     const normalized = typeof value === "string" ? value.trim() : "";
     return normalized || "gpt-5.4";
 }
-function normalizeCodexRpcRequest(args) {
-    const requestId = typeof args.request.requestId === "string" ? args.request.requestId.trim() : "";
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    const requestAgentId = typeof args.request.agentId === "string" ? args.request.agentId.trim() : "";
-    const runId = typeof args.request.runId === "string" ? args.request.runId.trim() : "";
-    const prompt = typeof args.request.prompt === "string" ? args.request.prompt.trim() : "";
-    if (!requestId || !responseSubject || !requestAgentId || requestAgentId !== args.agentId || !runId || !prompt) {
-        throw new Error("invalid codex rpc request");
-    }
-    return {
-        requestId,
-        responseSubject,
-        runId,
-        prompt,
-        sessionId: typeof args.request.sessionId === "string" && args.request.sessionId.trim() ? args.request.sessionId.trim() : null,
-        cwd: typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null,
-        model: normalizeCodexModel(args.request.model),
-        runtimeEnvPatch: normalizeEnvPatch(args.request.runtimeEnvPatch),
-        codexAuthBundle: normalizeShellRpcCodexAuthBundle(args.request.codexAuth),
-    };
-}
-function buildManagedCodexCommand(args) {
+function buildManagedCodexArgs(args) {
+    const promptArgs = ["--", args.prompt];
     const fixedArgs = ["--dangerously-bypass-approvals-and-sandbox"];
-    const codexArgs = args.sessionId
-        ? ["exec", "resume", "--json", args.sessionId, args.prompt]
-        : ["exec", "--json", args.prompt];
-    const commandArgs = [...fixedArgs, "--model", args.model, ...codexArgs].map(shellSingleQuote).join(" ");
-    const direct = `exec codex ${commandArgs}`;
-    const fallback = `exec npm exec --yes --package doer-agent -- codex ${commandArgs}`;
-    const script = [
-        "if command -v codex >/dev/null 2>&1; then",
-        `  ${direct}`,
-        "fi",
-        fallback,
-    ].join("\n");
-    return `bash -lc ${shellSingleQuote(script)}`;
-}
-function publishCodexRpcResponse(args) {
-    args.nc.publish(args.responseSubject, codexRpcCodec.encode(JSON.stringify(args.payload)));
+    return [
+        ...fixedArgs,
+        "--model",
+        args.model,
+        ...(args.sessionId
+            ? ["exec", "resume", "--json", args.sessionId, ...promptArgs]
+            : ["exec", "--json", ...promptArgs]),
+    ];
 }
 function buildLocalCodexCliCommand(args) {
     const quotedArgs = args.map(shellSingleQuote).join(" ");
@@ -1090,6 +1213,34 @@ function buildLocalCodexCliCommand(args) {
     ].join("\n");
     return `bash -lc ${shellSingleQuote(script)}`;
 }
+function hasDirectCodexBinary() {
+    const result = spawnSync("bash", ["-lc", "command -v codex >/dev/null 2>&1"], {
+        stdio: "ignore",
+    });
+    return result.status === 0;
+}
+function spawnManagedCodexCommand(args) {
+    const env = {
+        ...args.env,
+        DOER_AGENT_TOKEN: args.agentToken,
+    };
+    const child = hasDirectCodexBinary()
+        ? spawn("codex", args.codexArgs, {
+            cwd: args.taskWorkspace,
+            detached: process.platform !== "win32",
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        })
+        : spawn("npm", ["exec", "--yes", "--package", "doer-agent", "--", "codex", ...args.codexArgs], {
+            cwd: args.taskWorkspace,
+            detached: process.platform !== "win32",
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    return child;
+}
 async function runLocalCodexCli(args, timeoutMs) {
     const command = buildLocalCodexCliCommand(args);
     const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
@@ -1482,70 +1633,6 @@ function subscribeToCodexAuthRpc(args) {
     });
     writeAgentInfo(`codex auth rpc subscribed subject=${subject}`);
 }
-async function handleCodexRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    try {
-        const payload = JSON.parse(codexRpcCodec.decode(args.msg.data));
-        const request = normalizeCodexRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        const task = await startManagedRun({
-            requestId,
-            runId: request.runId,
-            serverBaseUrl: args.serverBaseUrl,
-            userId: args.userId,
-            agentId: args.agentId,
-            sessionId: request.sessionId,
-            command: buildManagedCodexCommand({
-                prompt: request.prompt,
-                sessionId: request.sessionId,
-                model: request.model,
-            }),
-            cwd: request.cwd,
-            runtimeEnvPatch: request.runtimeEnvPatch,
-            codexAuthBundle: request.codexAuthBundle,
-            agentToken: args.agentToken,
-        });
-        publishCodexRpcResponse({
-            nc: args.jetstream.nc,
-            responseSubject,
-            payload: { requestId, ok: true, task },
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishCodexRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: { requestId, ok: false, error: message },
-            });
-        }
-        writeAgentError(`codex rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToCodexRpc(args) {
-    const subject = buildAgentCodexRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`codex rpc subscription error: ${message}`);
-                return;
-            }
-            void handleCodexRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                serverBaseUrl: args.serverBaseUrl,
-                userId: args.userId,
-                agentId: args.agentId,
-                agentToken: args.agentToken,
-            });
-        },
-    });
-    writeAgentInfo(`codex rpc subscribed subject=${subject}`);
-}
 function runLocalCommand(command, args, cwd) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, args, {
@@ -1870,39 +1957,66 @@ async function handleRunRpcMessage(args) {
         requestId = request.requestId;
         responseSubject = request.responseSubject;
         if (request.action === "start") {
-            const task = await startManagedRun({
-                requestId,
-                runId: request.runId ?? requestId,
-                serverBaseUrl: args.serverBaseUrl,
-                userId: args.userId,
-                agentId: args.agentId,
-                sessionId: null,
-                command: request.command ?? "",
-                cwd: request.cwd,
-                runtimeEnvPatch: request.runtimeEnvPatch,
-                codexAuthBundle: request.codexAuthBundle,
-                agentToken: args.agentToken,
-            });
-            publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+            const runId = request.runId ?? requestId;
+            await claimRunStartSlot({ runId, sessionId: request.sessionId });
+            try {
+                const task = await startManagedRun({
+                    requestId,
+                    runId,
+                    serverBaseUrl: args.serverBaseUrl,
+                    userId: args.userId,
+                    agentId: args.agentId,
+                    sessionId: request.sessionId,
+                    codexArgs: buildManagedCodexArgs({
+                        prompt: request.prompt ?? "",
+                        sessionId: request.sessionId,
+                        model: request.model,
+                    }),
+                    cwd: request.cwd,
+                    runtimeEnvPatch: request.runtimeEnvPatch,
+                    codexAuthBundle: request.codexAuthBundle,
+                    agentToken: args.agentToken,
+                });
+                publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+            }
+            catch (error) {
+                await releaseRunStartSlot({ runId, sessionId: request.sessionId }).catch(() => undefined);
+                throw error;
+            }
             return;
         }
         if (request.action === "list") {
-            const tasks = [...activeRuns.values()].map((entry) => cloneRunTask(entry.task));
-            const retained = [...retainedRuns.values()].filter((task) => !activeRuns.has(task.id)).map((task) => cloneRunTask(task));
-            const merged = [...tasks, ...retained]
+            const persisted = await listPersistedRunTasks();
+            const mergedById = new Map();
+            for (const task of persisted) {
+                mergedById.set(task.id, cloneRunTask(task));
+            }
+            for (const task of retainedRuns.values()) {
+                if (!mergedById.has(task.id)) {
+                    mergedById.set(task.id, cloneRunTask(task));
+                }
+            }
+            const merged = [...mergedById.values()]
                 .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))
                 .slice(0, request.limit);
             publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, tasks: merged } });
             return;
         }
-        const stored = request.runId ? getStoredRun(request.runId) : null;
+        const stored = request.runId ? await getStoredRun(request.runId) : null;
         if (!stored || stored.agentId !== args.agentId || stored.userId !== args.userId) {
             throw new Error("Run not found");
         }
         if (request.action === "cancel") {
-            const active = activeRuns.get(stored.id);
-            active?.requestCancel();
-            const task = cloneRunTask(active?.task ?? stored);
+            const target = stored;
+            if (target.processPid === null) {
+                throw new Error("Run pid not found");
+            }
+            target.cancelRequested = true;
+            target.updatedAt = formatLocalTimestamp();
+            await persistRunTask(target);
+            writeRunStatus(target.id, `cancel requested pid=${target.processPid}`);
+            sendSignalToPid(target.processPid, "SIGINT");
+            const task = cloneRunTask(target);
             publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
             return;
         }
@@ -1978,21 +2092,17 @@ function sendSignalToTaskProcess(child, signal) {
         // noop
     }
 }
-function requestTaskCancellation(taskId, reason) {
-    const requestCancel = activeTaskCancelRequests.get(taskId);
-    if (!requestCancel) {
-        return false;
-    }
-    try {
-        requestCancel();
-        writeAgentInfo(`task cancel requested taskId=${taskId} via=${reason}`);
-        return true;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        writeAgentError(`task cancel request failed taskId=${taskId} via=${reason}: ${message}`);
-        return false;
+function sendSignalToPid(pid, signal) {
+    if (process.platform !== "win32") {
+        try {
+            process.kill(-pid, signal);
+            return;
+        }
+        catch {
+            // Fall back to direct pid signaling.
+        }
     }
+    process.kill(pid, signal);
 }
 function resolveLogTimeZone() {
     const configured = process.env.DOER_AGENT_LOG_TIMEZONE?.trim() || process.env.TZ?.trim();
@@ -2124,9 +2234,6 @@ function resolveTaskWorkspace(rawCwd) {
 function buildAgentFsRpcSubject(userId, agentId) {
     return `doer.agent.fs.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
-function buildAgentShellRpcSubject(userId, agentId) {
-    return `doer.agent.shell.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
-}
 function normalizeFsRpcPath(rawPath) {
     const root = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
     const raw = typeof rawPath === "string" && rawPath.trim() ? rawPath.trim() : ".";
@@ -2458,6 +2565,71 @@ function resolveSessionFilePath(filePath) {
 function isObjectRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
+const SESSION_RPC_BLOB_KEYS = new Set([
+    "image_url",
+    "image_base64",
+    "content_base64",
+    "file_data",
+    "bytes",
+    "data",
+]);
+function isInlineBlobString(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    return trimmed.startsWith("data:") || trimmed.includes(";base64,");
+}
+function buildInlineBlobMarker(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("data:")) {
+        const mimeEnd = trimmed.indexOf(";");
+        const mimeType = mimeEnd > 5 ? trimmed.slice(5, mimeEnd) : "";
+        if (mimeType) {
+            return `[inline blob omitted: ${mimeType}]`;
+        }
+    }
+    return "[inline blob omitted]";
+}
+function sanitizeSessionRpcPayload(value) {
+    if (typeof value === "string") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((entry) => sanitizeSessionRpcPayload(entry));
+    }
+    if (!isObjectRecord(value)) {
+        return value;
+    }
+    const sanitized = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (SESSION_RPC_BLOB_KEYS.has(key) && typeof entry === "string" && isInlineBlobString(entry)) {
+            sanitized[key] = buildInlineBlobMarker(entry);
+            continue;
+        }
+        sanitized[key] = sanitizeSessionRpcPayload(entry);
+    }
+    return sanitized;
+}
+function sanitizeSessionRpcRawLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("{")) {
+        return line;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        if (!isObjectRecord(parsed) || !isObjectRecord(parsed.payload) || parsed.type !== "response_item") {
+            return line;
+        }
+        return JSON.stringify({
+            ...parsed,
+            payload: sanitizeSessionRpcPayload(parsed.payload),
+        });
+    }
+    catch {
+        return line;
+    }
+}
 function toTrimmedStringOrNull(value) {
     if (typeof value !== "string") {
         return null;
@@ -2734,7 +2906,9 @@ async function getAgentSessionRawRows(args) {
     const sinceLine = Math.max(0, Math.floor(args.sinceLine));
     const beforeRowId = args.beforeRowId && args.beforeRowId > 0 ? Math.floor(args.beforeRowId) : null;
     const maxRawRows = 200;
-    const maxRawBytes = 120_000;
+    const maxSelectionBytes = 120_000;
+    const maxLineSelectionBytes = 4_096;
+    const maxReadBytes = 2_000_000;
     if (totalLines === 0) {
         return {
             rawRows: [],
@@ -2752,46 +2926,64 @@ async function getAgentSessionRawRows(args) {
         endLineIndex = Math.max(0, Math.min(totalLines, beforeRowId - 1));
         startLineIndex = endLineIndex;
         let collectedRows = 0;
-        let collectedBytes = 0;
+        let collectedSelectionBytes = 0;
+        let collectedReadBytes = 0;
         while (startLineIndex > 0 && collectedRows < maxRawRows) {
             const nextIndex = startLineIndex - 1;
-            const nextBytes = getLineSpanBytes(nextIndex);
-            if (collectedRows > 0 && collectedBytes + nextBytes > maxRawBytes) {
+            const nextReadBytes = getLineSpanBytes(nextIndex);
+            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
+            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
+                break;
+            }
+            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
                 break;
             }
             startLineIndex = nextIndex;
             collectedRows += 1;
-            collectedBytes += nextBytes;
+            collectedSelectionBytes += nextSelectionBytes;
+            collectedReadBytes += nextReadBytes;
         }
     }
     else if (sinceLine > 0) {
         startLineIndex = Math.min(totalLines, sinceLine);
         endLineIndex = startLineIndex;
         let collectedRows = 0;
-        let collectedBytes = 0;
+        let collectedSelectionBytes = 0;
+        let collectedReadBytes = 0;
         while (endLineIndex < totalLines && collectedRows < maxRawRows) {
-            const nextBytes = getLineSpanBytes(endLineIndex);
-            if (collectedRows > 0 && collectedBytes + nextBytes > maxRawBytes) {
+            const nextReadBytes = getLineSpanBytes(endLineIndex);
+            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
+            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
+                break;
+            }
+            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
                 break;
             }
             endLineIndex += 1;
             collectedRows += 1;
-            collectedBytes += nextBytes;
+            collectedSelectionBytes += nextSelectionBytes;
+            collectedReadBytes += nextReadBytes;
         }
     }
     else {
         startLineIndex = totalLines;
         let collectedRows = 0;
-        let collectedBytes = 0;
+        let collectedSelectionBytes = 0;
+        let collectedReadBytes = 0;
         while (startLineIndex > 0 && collectedRows < maxRawRows) {
             const nextIndex = startLineIndex - 1;
-            const nextBytes = getLineSpanBytes(nextIndex);
-            if (collectedRows > 0 && collectedBytes + nextBytes > maxRawBytes) {
+            const nextReadBytes = getLineSpanBytes(nextIndex);
+            const nextSelectionBytes = Math.min(nextReadBytes, maxLineSelectionBytes);
+            if (collectedRows > 0 && collectedSelectionBytes + nextSelectionBytes > maxSelectionBytes) {
+                break;
+            }
+            if (collectedRows > 0 && collectedReadBytes + nextReadBytes > maxReadBytes) {
                 break;
             }
             startLineIndex = nextIndex;
             collectedRows += 1;
-            collectedBytes += nextBytes;
+            collectedSelectionBytes += nextSelectionBytes;
+            collectedReadBytes += nextReadBytes;
         }
     }
     if (startLineIndex >= endLineIndex) {
@@ -2824,7 +3016,7 @@ async function getAgentSessionRawRows(args) {
             if (line.trim()) {
                 rawRows.push({
                     id: lineNumber,
-                    raw: line,
+                    raw: sanitizeSessionRpcRawLine(line),
                 });
             }
             lineNumber += 1;
@@ -3055,46 +3247,6 @@ function subscribeToFsRpc(args) {
     });
     writeAgentInfo(`fs rpc subscribed subject=${subject}`);
 }
-function normalizeShellRpcRequest(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) {
-        throw new Error("missing agentId");
-    }
-    if (requestAgentId !== args.agentId) {
-        throw new Error("agent id mismatch");
-    }
-    const kind = args.request.kind === "apply_patch" ? "apply_patch" : "shell";
-    const command = typeof args.request.command === "string" ? args.request.command.trim() : "";
-    const patch = typeof args.request.patch === "string" ? args.request.patch : "";
-    if (kind === "shell" && !command) {
-        throw new Error("missing command");
-    }
-    if (kind === "apply_patch" && !patch.trim()) {
-        throw new Error("missing patch");
-    }
-    const responseSubject = typeof args.request.responseSubject === "string" ? args.request.responseSubject.trim() : "";
-    if (!responseSubject) {
-        throw new Error("missing responseSubject");
-    }
-    const cwd = typeof args.request.cwd === "string" && args.request.cwd.trim() ? args.request.cwd.trim() : null;
-    const timeoutRaw = Number(args.request.timeoutMs);
-    const timeoutMs = Number.isFinite(timeoutRaw) ? Math.max(1000, Math.min(Math.floor(timeoutRaw), 300000)) : 30000;
-    return {
-        kind,
-        requestId,
-        command: kind === "shell" ? command : null,
-        patch: kind === "apply_patch" ? patch : null,
-        cwd,
-        timeoutMs,
-        responseSubject,
-        runtimeEnvPatch: normalizeEnvPatch(args.request.runtimeEnvPatch),
-        codexAuthBundle: normalizeShellRpcCodexAuthBundle(args.request.codexAuth),
-    };
-}
 function normalizeShellRpcCodexAuthBundle(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return null;
@@ -3113,118 +3265,6 @@ function normalizeShellRpcCodexAuthBundle(value) {
         apiKey: typeof row.apiKey === "string" || row.apiKey === null ? row.apiKey : undefined,
     };
 }
-function publishShellRpcResponse(args) {
-    args.nc.publish(args.responseSubject, shellRpcCodec.encode(JSON.stringify(args.payload)));
-}
-async function handleShellRpcMessage(args) {
-    let requestId = "unknown";
-    let responseSubject = "";
-    let stdout = "";
-    let stderr = "";
-    try {
-        const payload = JSON.parse(shellRpcCodec.decode(args.msg.data));
-        const request = normalizeShellRpcRequest({ request: payload, agentId: args.agentId });
-        requestId = request.requestId;
-        responseSubject = request.responseSubject;
-        const startedAtMs = Date.now();
-        const prepared = await prepareCommandExecution({
-            cwd: request.cwd,
-            userId: args.userId,
-            taskId: request.requestId,
-            codexAuthBundle: request.codexAuthBundle,
-        });
-        const child = spawnPreparedCommand({
-            kind: request.kind,
-            command: request.command,
-            patch: request.patch,
-            shellPath: prepared.shellPath,
-            taskWorkspace: prepared.taskWorkspace,
-            env: prepared.env,
-            agentToken: args.agentToken,
-        });
-        writeRpcStatus(requestId, `started kind=${request.kind} cwd=${prepared.taskWorkspace} shell=${request.kind === "shell" ? prepared.shellPath : "apply_patch"}`);
-        child.stdout.on("data", (chunk) => {
-            stdout += chunk;
-            writeRpcStream(requestId, "stdout", chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += chunk;
-            writeRpcStream(requestId, "stderr", chunk);
-        });
-        let timedOut = false;
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            sendSignalToTaskProcess(child, "SIGTERM");
-            setTimeout(() => {
-                sendSignalToTaskProcess(child, "SIGKILL");
-            }, 1000).unref?.();
-        }, request.timeoutMs);
-        timeout.unref?.();
-        const result = await new Promise((resolve, reject) => {
-            child.once("error", reject);
-            child.once("close", (code, signal) => {
-                resolve({ exitCode: typeof code === "number" ? code : null, signal });
-            });
-        }).finally(() => {
-            clearTimeout(timeout);
-        });
-        await prepared.codexAuthCleanup().catch(() => undefined);
-        publishShellRpcResponse({
-            nc: args.jetstream.nc,
-            responseSubject,
-            payload: {
-                requestId,
-                ok: !timedOut,
-                exitCode: result.exitCode,
-                signal: result.signal,
-                stdout,
-                stderr,
-                ...(timedOut ? { error: `Command timed out after ${request.timeoutMs}ms` } : {}),
-            },
-        });
-        writeRpcStatus(requestId, `${timedOut ? "timed_out" : "completed"} exitCode=${result.exitCode ?? "null"} signal=${result.signal ?? "null"} durationMs=${Date.now() - startedAtMs}`);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (responseSubject) {
-            publishShellRpcResponse({
-                nc: args.jetstream.nc,
-                responseSubject,
-                payload: {
-                    requestId,
-                    ok: false,
-                    exitCode: null,
-                    signal: null,
-                    stdout,
-                    stderr,
-                    error: message,
-                },
-            });
-        }
-        writeRpcStatus(requestId, `failed error=${message}`);
-        writeAgentError(`shell rpc failed requestId=${requestId} error=${message}`);
-    }
-}
-function subscribeToShellRpc(args) {
-    const subject = buildAgentShellRpcSubject(args.userId, args.agentId);
-    args.jetstream.nc.subscribe(subject, {
-        callback: (error, msg) => {
-            if (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`shell rpc subscription error: ${message}`);
-                return;
-            }
-            void handleShellRpcMessage({
-                msg,
-                jetstream: args.jetstream,
-                userId: args.userId,
-                agentId: args.agentId,
-                agentToken: args.agentToken,
-            });
-        },
-    });
-    writeAgentInfo(`shell rpc subscribed subject=${subject}`);
-}
 async function postJson(url, body) {
     const res = await fetch(url, {
         method: "POST",
@@ -3472,36 +3512,6 @@ function spawnPreparedCommand(args) {
     child.stderr.setEncoding("utf8");
     return child;
 }
-function createManagedCancellation(child) {
-    let cancelStage1Timer = null;
-    let cancelStage2Timer = null;
-    let cancelSignalSent = false;
-    return {
-        requestCancel: () => {
-            if (cancelSignalSent) {
-                return;
-            }
-            cancelSignalSent = true;
-            sendSignalToTaskProcess(child, "SIGINT");
-            cancelStage1Timer = setTimeout(() => {
-                sendSignalToTaskProcess(child, "SIGTERM");
-            }, 1200);
-            cancelStage1Timer.unref?.();
-            cancelStage2Timer = setTimeout(() => {
-                sendSignalToTaskProcess(child, "SIGKILL");
-            }, 3500);
-            cancelStage2Timer.unref?.();
-        },
-        clear: () => {
-            if (cancelStage1Timer) {
-                clearTimeout(cancelStage1Timer);
-            }
-            if (cancelStage2Timer) {
-                clearTimeout(cancelStage2Timer);
-            }
-        },
-    };
-}
 async function runTask(args) {
     activeTaskLogContext = {
         jetstream: args.jetstream,
@@ -3595,7 +3605,6 @@ async function runTask(args) {
             }, 3500);
             cancelStage2Timer.unref?.();
         };
-        activeTaskCancelRequests.set(args.taskId, requestCancel);
         child.stdout.on("data", (chunk) => {
             writeTaskStream(args.taskId, "stdout", chunk);
             const seq = reserveNextEventSeq(args.taskId);
@@ -3690,7 +3699,6 @@ async function runTask(args) {
         writeAgentInfo(`task=${args.taskId} status=${status} exitCode=${typeof result.code === "number" ? result.code : "null"} signal=${result.signal ?? "null"}`);
     }
     finally {
-        activeTaskCancelRequests.delete(args.taskId);
         activeTaskLogContext = null;
         await codexAuth?.cleanup().catch(() => undefined);
     }
@@ -3794,24 +3802,11 @@ async function main() {
         agentId: initialAgentId,
         agentToken,
     });
-    subscribeToShellRpc({
-        jetstream,
-        userId,
-        agentId: initialAgentId,
-        agentToken,
-    });
     subscribeToSessionRpc({
         jetstream,
         userId,
         agentId: initialAgentId,
     });
-    subscribeToCodexRpc({
-        jetstream,
-        serverBaseUrl,
-        userId,
-        agentId: initialAgentId,
-        agentToken,
-    });
     subscribeToCodexAuthRpc({
         jetstream,
         userId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",