doer-agent 0.2.6 → 0.2.7

package/dist/agent.js

@@ -9,16 +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 codexAuthRpcCodec = StringCodec();
 const settingsRpcCodec = StringCodec();
 const gitRpcCodec = StringCodec();
-const activeRuns = new Map();
 const retainedRuns = new Map();
 const activeSessionWatchers = new Map();
 const sessionLineIndexCache = new Map();
@@ -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,
@@ -1020,10 +1020,71 @@ async function updateRunSessionMetadata(task, metadata) {
 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;
 }
@@ -1045,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",
@@ -1057,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);
@@ -1096,33 +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}`);
@@ -1935,22 +1986,37 @@ async function handleRunRpcMessage(args) {
             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;
         }
@@ -2026,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();
@@ -2172,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() : ".";
@@ -3188,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;
@@ -3246,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",
@@ -3605,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,
@@ -3728,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);
@@ -3823,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);
     }
@@ -3927,12 +3802,6 @@ async function main() {
         agentId: initialAgentId,
         agentToken,
     });
-    subscribeToShellRpc({
-        jetstream,
-        userId,
-        agentId: initialAgentId,
-        agentToken,
-    });
     subscribeToSessionRpc({
         jetstream,
         userId,

package/package.json

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