doer-agent 0.2.2 → 0.2.4

package/dist/agent.js

@@ -1,5 +1,5 @@
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, statSync } from "node:fs";
+import { createWriteStream, existsSync, statSync } from "node:fs";
 import { chmod, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -13,10 +13,16 @@ const activeTaskCancelRequests = new Map();
 let workspaceRootOverride = null;
 const fsRpcCodec = StringCodec();
 const shellRpcCodec = StringCodec();
+const runRpcCodec = StringCodec();
+const activeRuns = new Map();
+const retainedRuns = new Map();
 function sanitizeUserId(userId) {
     const normalized = userId.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
     return normalized.length > 0 ? normalized : "anonymous";
 }
+function buildAgentRunRpcSubject(userId, agentId) {
+    return `doer.agent.run.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 function normalizeNatsServers(value) {
     if (!Array.isArray(value)) {
         return [];
@@ -92,12 +98,6 @@ async function initJetStreamContext(args) {
     const nc = await connect(args.token ? { servers: args.servers, token: args.token } : { servers: args.servers });
     const jsm = await nc.jetstreamManager();
     await ensureJetStreamInfra({ jsm, stream, subject, durable });
-    await ensureJetStreamInfra({
-        jsm,
-        stream: args.taskStream,
-        subject: args.taskSubject,
-        durable: args.taskDurable,
-    });
     void nc.closed().then((error) => {
         if (error) {
             writeAgentInfraError(`nats connection closed with error: ${error.message}`);
@@ -126,14 +126,10 @@ async function initJetStreamContext(args) {
         js: nc.jetstream(),
         jsm,
         codec: JSONCodec(),
-        taskCodec: JSONCodec(),
         subject,
         stream,
         durable,
         servers: args.servers,
-        taskStream: args.taskStream,
-        taskSubject: args.taskSubject,
-        taskDurable: args.taskDurable,
     };
 }
 function resolveCodexHomePath() {
@@ -371,6 +367,311 @@ function writeRpcStream(requestId, stream, chunk) {
 function writeRpcStatus(requestId, message) {
     process.stdout.write(`[doer-agent][rpc=${requestId}][status] ${message}\n`);
 }
+function writeRunStatus(runId, message) {
+    process.stdout.write(`[doer-agent][run=${runId}][status] ${message}\n`);
+}
+function writeRunStream(runId, stream, chunk) {
+    const target = stream === "stdout" ? process.stdout : process.stderr;
+    const lines = chunk.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line && index === lines.length - 1) {
+            continue;
+        }
+        target.write(`[doer-agent][run=${runId}][${stream}] ${line}\n`);
+    }
+}
+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 command = typeof args.request.command === "string" && args.request.command.trim() ? args.request.command.trim() : null;
+    if (action === "start" && !command) {
+        throw new Error("missing command");
+    }
+    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 chatId = typeof args.request.chatId === "string" && args.request.chatId.trim() ? args.request.chatId.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,
+        command,
+        cwd,
+        chatId,
+        responseSubject,
+        sinceSeq,
+        limit,
+        runtimeEnvPatch: normalizeEnvPatch(args.request.runtimeEnvPatch),
+        codexAuthBundle: normalizeShellRpcCodexAuthBundle(args.request.codexAuth),
+    };
+}
+function publishRunRpcResponse(args) {
+    args.nc.publish(args.responseSubject, runRpcCodec.encode(JSON.stringify(args.payload)));
+}
+async function resolveRunLogsDir() {
+    const workspaceRoot = workspaceRootOverride ?? (process.env.WORKSPACE?.trim() || process.cwd());
+    const dir = path.join(workspaceRoot, ".doer-agent", "runs");
+    await mkdir(dir, { recursive: true });
+    return dir;
+}
+function cloneRunTask(task, sinceSeq) {
+    return {
+        ...task,
+        events: task.events
+            .filter((event) => typeof sinceSeq === "number" ? event.seq > sinceSeq : true)
+            .map((event) => ({ ...event, payload: { ...event.payload } })),
+    };
+}
+function appendRunEvent(task, type, payload) {
+    const timestamp = formatLocalTimestamp();
+    const seq = task.agentEventAckSeq + 1;
+    task.agentEventAckSeq = seq;
+    task.updatedAt = timestamp;
+    task.events.push({ seq, type, timestamp, payload });
+}
+function persistRetainedRun(task) {
+    retainedRuns.set(task.id, cloneRunTask(task));
+}
+function getStoredRun(runId) {
+    const active = activeRuns.get(runId);
+    if (active) {
+        return active.task;
+    }
+    return retainedRuns.get(runId) ?? null;
+}
+async function startManagedRun(args) {
+    const prepared = await prepareCommandExecution({
+        cwd: args.cwd,
+        runtimeEnvPatch: args.runtimeEnvPatch,
+        codexAuthBundle: args.codexAuthBundle,
+    });
+    const child = spawnPreparedCommand({
+        kind: "shell",
+        command: args.command,
+        patch: null,
+        shellPath: prepared.shellPath,
+        taskWorkspace: prepared.taskWorkspace,
+        env: prepared.env,
+        agentToken: args.agentToken,
+    });
+    const logsDir = await resolveRunLogsDir();
+    const logPath = path.join(logsDir, `${args.runId}.log`);
+    const logStream = createWriteStream(logPath, { flags: "a", encoding: "utf8" });
+    const now = formatLocalTimestamp();
+    const task = {
+        id: args.runId,
+        userId: args.userId,
+        agentId: args.agentId,
+        command: args.command,
+        cwd: args.cwd,
+        chatId: args.chatId,
+        status: "running",
+        cancelRequested: false,
+        resultExitCode: null,
+        resultSignal: null,
+        error: null,
+        createdAt: now,
+        updatedAt: now,
+        startedAt: now,
+        finishedAt: null,
+        agentEventAckSeq: 0,
+        events: [],
+    };
+    appendRunEvent(task, "meta", {
+        host: process.platform,
+        pid: child.pid ?? null,
+        startedAt: now,
+        command: args.command,
+        cwd: prepared.taskWorkspace,
+        requestedCwd: args.cwd,
+        shell: prepared.shellPath,
+        logPath,
+        ...prepared.taskGitMeta,
+        ...prepared.codexAuthMeta,
+    });
+    appendRunEvent(task, "status", { status: "running" });
+    const cancellation = createManagedCancellation(child);
+    const requestCancel = () => {
+        if (task.status === "completed" || task.status === "failed" || task.status === "canceled") {
+            return;
+        }
+        task.cancelRequested = true;
+        task.updatedAt = formatLocalTimestamp();
+        writeRunStatus(task.id, "cancel requested");
+        cancellation.requestCancel();
+    };
+    const recordChunk = (stream, chunk) => {
+        appendRunEvent(task, stream, { chunk, at: formatLocalTimestamp() });
+        logStream.write(JSON.stringify({ at: formatLocalTimestamp(), stream, chunk }) + "\n");
+        writeRunStream(task.id, stream, chunk);
+    };
+    child.stdout.on("data", (chunk) => recordChunk("stdout", chunk));
+    child.stderr.on("data", (chunk) => recordChunk("stderr", chunk));
+    child.once("error", (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        task.status = "failed";
+        task.error = message;
+        task.finishedAt = formatLocalTimestamp();
+        appendRunEvent(task, "status", { status: "failed", error: message, finishedAt: task.finishedAt });
+        persistRetainedRun(task);
+        activeRuns.delete(task.id);
+        logStream.end();
+        void prepared.codexAuthCleanup().catch(() => undefined);
+        writeRunStatus(task.id, `failed error=${message}`);
+    });
+    child.once("close", (code, signal) => {
+        cancellation.clear();
+        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;
+        appendRunEvent(task, "status", {
+            status: task.status,
+            exitCode: task.resultExitCode,
+            signal: task.resultSignal,
+            error: task.error,
+            finishedAt: task.finishedAt,
+        });
+        persistRetainedRun(task);
+        activeRuns.delete(task.id);
+        logStream.end();
+        void prepared.codexAuthCleanup().catch(() => undefined);
+        if ((task.status === "completed" || task.status === "failed") && task.chatId) {
+            void notifyServerRunFinished({
+                serverBaseUrl: args.serverBaseUrl,
+                userId: args.userId,
+                agentToken: args.agentToken,
+                task,
+            }).catch((error) => {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentInfraError(`run completion notify failed runId=${task.id}: ${message}`);
+            });
+        }
+        writeRunStatus(task.id, `completed status=${task.status} exitCode=${task.resultExitCode ?? "null"} signal=${task.resultSignal ?? "null"}`);
+    });
+    activeRuns.set(task.id, { task, child, logPath, logStream, requestCancel });
+    persistRetainedRun(task);
+    writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
+    return cloneRunTask(task);
+}
+async function notifyServerRunFinished(args) {
+    if (!args.task.chatId || (args.task.status !== "completed" && args.task.status !== "failed")) {
+        return;
+    }
+    await postJson(`${args.serverBaseUrl}/api/agent/run-finished`, {
+        userId: args.userId,
+        agentToken: args.agentToken,
+        chatId: args.task.chatId,
+        runId: args.task.id,
+        command: args.task.command,
+        status: args.task.status,
+        exitCode: args.task.resultExitCode,
+        signal: args.task.resultSignal,
+        finishedAt: args.task.finishedAt,
+        error: args.task.error,
+    });
+}
+async function handleRunRpcMessage(args) {
+    let requestId = "unknown";
+    let responseSubject = "";
+    try {
+        const payload = JSON.parse(runRpcCodec.decode(args.msg.data));
+        const request = normalizeRunRpcRequest({ request: payload, agentId: args.agentId });
+        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,
+                command: request.command ?? "",
+                cwd: request.cwd,
+                chatId: request.chatId,
+                runtimeEnvPatch: request.runtimeEnvPatch,
+                codexAuthBundle: request.codexAuthBundle,
+                agentToken: args.agentToken,
+            });
+            publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+            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]
+                .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;
+        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);
+            publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+            return;
+        }
+        const task = cloneRunTask(stored, request.sinceSeq);
+        publishRunRpcResponse({ nc: args.jetstream.nc, responseSubject, payload: { requestId, ok: true, task } });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (responseSubject) {
+            publishRunRpcResponse({
+                nc: args.jetstream.nc,
+                responseSubject,
+                payload: { requestId, ok: false, error: message },
+            });
+        }
+        writeAgentError(`run rpc failed requestId=${requestId} error=${message}`);
+    }
+}
+function subscribeToRunRpc(args) {
+    const subject = buildAgentRunRpcSubject(args.userId, args.agentId);
+    args.jetstream.nc.subscribe(subject, {
+        callback: (error, msg) => {
+            if (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                writeAgentError(`run rpc subscription error: ${message}`);
+                return;
+            }
+            void handleRunRpcMessage({
+                msg,
+                jetstream: args.jetstream,
+                serverBaseUrl: args.serverBaseUrl,
+                userId: args.userId,
+                agentId: args.agentId,
+                agentToken: args.agentToken,
+            });
+        },
+    });
+    writeAgentInfo(`run rpc subscribed subject=${subject}`);
+}
 function isLikelyNatsAuthError(error) {
     const message = (error instanceof Error ? error.message : String(error)).toLowerCase();
     return (message.includes("auth")
@@ -827,53 +1128,21 @@ async function handleShellRpcMessage(args) {
         requestId = request.requestId;
         responseSubject = request.responseSubject;
         const startedAtMs = Date.now();
-        const shellPath = resolveShellPath();
-        const taskWorkspace = resolveTaskWorkspace(request.cwd);
-        const codexAuth = await prepareCodexAuthBundle(request.codexAuthBundle);
-        const baseTaskEnvPatch = {
-            ...request.runtimeEnvPatch,
-            ...(codexAuth?.envPatch ?? {}),
-            WORKSPACE: taskWorkspace,
-        };
-        const taskGitEnv = await prepareTaskGitEnv({
-            cwd: taskWorkspace,
-            baseEnvPatch: baseTaskEnvPatch,
+        const prepared = await prepareCommandExecution({
+            cwd: request.cwd,
+            runtimeEnvPatch: request.runtimeEnvPatch,
+            codexAuthBundle: request.codexAuthBundle,
         });
-        const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "runtime/bin");
-        const taskPath = [runtimeBinPath, process.env.PATH || ""].filter(Boolean).join(path.delimiter);
-        const child = request.kind === "apply_patch"
-            ? spawn("apply_patch", {
-                cwd: taskWorkspace,
-                detached: process.platform !== "win32",
-                env: {
-                    ...process.env,
-                    ...baseTaskEnvPatch,
-                    ...taskGitEnv.envPatch,
-                    PATH: taskPath,
-                    DOER_AGENT_TOKEN: args.agentToken,
-                },
-                stdio: ["pipe", "pipe", "pipe"],
-            })
-            : spawn(request.command ?? "", {
-                cwd: taskWorkspace,
-                shell: shellPath,
-                detached: process.platform !== "win32",
-                env: {
-                    ...process.env,
-                    ...baseTaskEnvPatch,
-                    ...taskGitEnv.envPatch,
-                    PATH: taskPath,
-                    DOER_AGENT_TOKEN: args.agentToken,
-                },
-                stdio: ["ignore", "pipe", "pipe"],
-            });
-        if (request.kind === "apply_patch") {
-            child.stdin?.write(request.patch ?? "");
-            child.stdin?.end();
-        }
-        writeRpcStatus(requestId, `started kind=${request.kind} cwd=${taskWorkspace} shell=${request.kind === "shell" ? shellPath : "apply_patch"}`);
-        child.stdout.setEncoding("utf8");
-        child.stderr.setEncoding("utf8");
+        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);
@@ -899,6 +1168,7 @@ async function handleShellRpcMessage(args) {
         }).finally(() => {
             clearTimeout(timeout);
         });
+        await prepared.codexAuthCleanup().catch(() => undefined);
         publishShellRpcResponse({
             nc: args.jetstream.nc,
             responseSubject,
@@ -1154,6 +1424,93 @@ async function prepareCodexAuthBundle(bundle) {
         },
     };
 }
+async function prepareCommandExecution(args) {
+    const shellPath = resolveShellPath();
+    const taskWorkspace = resolveTaskWorkspace(args.cwd);
+    const codexAuth = await prepareCodexAuthBundle(args.codexAuthBundle);
+    const baseTaskEnvPatch = {
+        ...args.runtimeEnvPatch,
+        ...(codexAuth?.envPatch ?? {}),
+        WORKSPACE: taskWorkspace,
+    };
+    const taskGitEnv = await prepareTaskGitEnv({
+        cwd: taskWorkspace,
+        baseEnvPatch: baseTaskEnvPatch,
+    });
+    const runtimeBinPath = path.join(AGENT_PROJECT_DIR, "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 () => { }),
+    };
+}
+function spawnPreparedCommand(args) {
+    const env = {
+        ...args.env,
+        DOER_AGENT_TOKEN: args.agentToken,
+    };
+    const child = args.kind === "apply_patch"
+        ? spawn("apply_patch", {
+            cwd: args.taskWorkspace,
+            detached: process.platform !== "win32",
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        })
+        : spawn(args.command ?? "", {
+            cwd: args.taskWorkspace,
+            shell: args.shellPath,
+            detached: process.platform !== "win32",
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+    if (args.kind === "apply_patch") {
+        child.stdin?.write(args.patch ?? "");
+        child.stdin?.end();
+    }
+    child.stdout.setEncoding("utf8");
+    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,
@@ -1355,22 +1712,14 @@ async function connectBootstrapWithRetry(args) {
             if (natsServers.length === 0) {
                 throw new Error("No NATS servers configured by server");
             }
-            const taskConfig = parseBootstrapTaskConfig(natsBootstrap.tasks);
-            if (!taskConfig) {
-                throw new Error("Invalid task dispatch config from server");
-            }
             const natsToken = normalizeNatsToken(natsBootstrap.auth);
-            const pendingTaskIds = normalizeTaskIds(natsBootstrap.pendingTaskIds);
             const jetstream = await initJetStreamContext({
                 userId: args.userId,
                 servers: natsServers,
                 token: natsToken,
-                taskStream: taskConfig.stream,
-                taskSubject: taskConfig.subject,
-                taskDurable: taskConfig.durable,
             });
-            writeAgentInfraError(`bootstrap ok servers=${natsServers.length} taskStream=${taskConfig.stream} taskSubject=${taskConfig.subject} taskDurable=${taskConfig.durable}`);
-            return { natsBootstrap, pendingTaskIds, jetstream };
+            writeAgentInfraError(`bootstrap ok servers=${natsServers.length} eventStream=${jetstream.stream} eventSubject=${jetstream.subject}`);
+            return { natsBootstrap, jetstream };
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -1396,12 +1745,11 @@ async function main() {
         throw new Error("user-id and agent-secret are required");
     }
     const agentToken = agentSecret;
-    let { natsBootstrap, pendingTaskIds, jetstream } = await connectBootstrapWithRetry({
+    const { natsBootstrap, jetstream } = await connectBootstrapWithRetry({
         serverBaseUrl,
         userId,
         agentToken,
     });
-    const maxConcurrency = Math.max(1, parseEnvInteger(process.env.DOER_AGENT_MAX_CONCURRENCY, 5));
     const agentVersion = await resolveAgentVersion();
     const initialAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
     if (!initialAgentId) {
@@ -1418,11 +1766,6 @@ async function main() {
     process.stdout.write(`- natsStream: ${jetstream.stream}\n`);
     process.stdout.write(`- natsSubject: ${jetstream.subject}\n`);
     process.stdout.write(`- natsDurable: ${jetstream.durable}\n\n`);
-    process.stdout.write(`- taskStream: ${jetstream.taskStream}\n`);
-    process.stdout.write(`- taskSubject: ${jetstream.taskSubject}\n`);
-    process.stdout.write(`- taskDurable: ${jetstream.taskDurable}\n`);
-    process.stdout.write(`- pendingTasks: ${pendingTaskIds.length}\n`);
-    process.stdout.write(`- maxConcurrency: ${maxConcurrency}\n\n`);
     process.stdout.write(`- workspace: ${process.cwd()}\n\n`);
     if (requestedServerBaseUrl !== serverBaseUrl) {
         writeAgentInfo(`detected container runtime, server endpoint rewritten: ${requestedServerBaseUrl} -> ${serverBaseUrl}`);
@@ -1444,27 +1787,6 @@ async function main() {
             heartbeatHealthy = false;
         });
     }, 10_000);
-    const inFlightTasks = new Set();
-    async function waitForAvailableSlot() {
-        while (inFlightTasks.size >= maxConcurrency) {
-            try {
-                await Promise.race(inFlightTasks);
-            }
-            catch {
-                // keep draining slots even when a task fails.
-            }
-        }
-    }
-    function trackInFlight(taskPromise) {
-        inFlightTasks.add(taskPromise);
-        void taskPromise.finally(() => {
-            inFlightTasks.delete(taskPromise);
-        });
-    }
-    function scheduleTask(taskPromiseFactory) {
-        const taskPromise = taskPromiseFactory();
-        trackInFlight(taskPromise);
-    }
     subscribeToFsRpc({
         jetstream,
         serverBaseUrl,
@@ -1478,176 +1800,16 @@ async function main() {
         agentId: initialAgentId,
         agentToken,
     });
-    for (const pendingTaskId of pendingTaskIds) {
-        await waitForAvailableSlot();
-        scheduleTask(async () => {
-            try {
-                const task = await claimTaskById({
-                    serverBaseUrl,
-                    userId,
-                    agentToken,
-                    taskId: pendingTaskId,
-                });
-                if (task) {
-                    await runClaimedTask({ task, serverBaseUrl, userId, agentToken, jetstream });
-                }
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                writeAgentError(`pending task bootstrap failed taskId=${pendingTaskId}: ${message}`);
-            }
-        });
-    }
-    let connected = false;
-    while (true) {
-        try {
-            const consumer = await jetstream.js.consumers.get(jetstream.taskStream, jetstream.taskDurable);
-            if (!connected) {
-                writeAgentInfo(`connected to task stream (NATS ok) at=${formatLocalTimestamp()} userId=${userId}`);
-                connected = true;
-            }
-            const messages = await consumer.fetch({ max_messages: 200, expires: 5_000 });
-            for await (const msg of messages) {
-                await waitForAvailableSlot();
-                scheduleTask(async () => {
-                    let dispatch;
-                    try {
-                        dispatch = jetstream.taskCodec.decode(msg.data);
-                    }
-                    catch (error) {
-                        const message = error instanceof Error ? error.message : String(error);
-                        writeAgentError(`task dispatch decode failed: ${message}`);
-                        msg.term();
-                        return;
-                    }
-                    writeAgentInfo(`task dispatch received taskId=${dispatch.taskId} createdAt=${dispatch.createdAt} subject=${jetstream.taskSubject} durable=${jetstream.taskDurable}`);
-                    const ackKeepAliveIntervalMs = 10_000;
-                    let ackKeepAliveTimer = null;
-                    const stopAckKeepAlive = () => {
-                        if (ackKeepAliveTimer) {
-                            clearInterval(ackKeepAliveTimer);
-                            ackKeepAliveTimer = null;
-                        }
-                    };
-                    try {
-                        ackKeepAliveTimer = setInterval(() => {
-                            try {
-                                msg.working();
-                            }
-                            catch (error) {
-                                const message = error instanceof Error ? error.message : String(error);
-                                writeAgentError(`task dispatch keepalive failed taskId=${dispatch.taskId}: ${message}`);
-                            }
-                        }, ackKeepAliveIntervalMs);
-                        ackKeepAliveTimer.unref?.();
-                        if (dispatch.type === "cancel") {
-                            stopAckKeepAlive();
-                            const canceled = requestTaskCancellation(dispatch.taskId, "nats_dispatch");
-                            writeAgentInfo(`task cancel dispatch handled taskId=${dispatch.taskId} result=${canceled ? "signaled" : "not-running"}`);
-                            msg.ack();
-                            return;
-                        }
-                        const task = await claimTaskById({
-                            serverBaseUrl,
-                            userId,
-                            agentToken,
-                            taskId: dispatch.taskId,
-                        });
-                        if (!task) {
-                            stopAckKeepAlive();
-                            writeAgentInfo(`task dispatch acked without run taskId=${dispatch.taskId} reason=already-claimed`);
-                            msg.ack();
-                            return;
-                        }
-                        await runClaimedTask({ task, serverBaseUrl, userId, agentToken, jetstream });
-                        stopAckKeepAlive();
-                        msg.ack();
-                        writeAgentInfo(`task dispatch acked taskId=${dispatch.taskId}`);
-                    }
-                    catch (error) {
-                        stopAckKeepAlive();
-                        const message = error instanceof Error ? error.message : String(error);
-                        writeAgentError(`task dispatch handle failed taskId=${dispatch.taskId}: ${message}`);
-                        writeAgentError(`task dispatch sending nak taskId=${dispatch.taskId}`);
-                        msg.nak();
-                    }
-                });
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            if (connected) {
-                writeAgentError(`task stream disconnected at=${formatLocalTimestamp()} reason=${message}`);
-            }
-            connected = false;
-            if (isLikelyNatsAuthError(error)) {
-                writeAgentError(`nats auth error detected. refreshing bootstrap credentials...`);
-            }
-            else if (isLikelyNatsReconnectError(error)) {
-                writeAgentError(`nats connection lost. refreshing bootstrap/session...`);
-            }
-            else {
-                writeAgentError(`task stream error detected. forcing bootstrap/session refresh... reason=${message}`);
-            }
-            if (inFlightTasks.size > 0) {
-                writeAgentInfo(`waiting for in-flight tasks before reconnect count=${inFlightTasks.size}`);
-                await Promise.allSettled(Array.from(inFlightTasks));
-            }
-            try {
-                await jetstream.nc.close();
-            }
-            catch {
-                // noop
-            }
-            const refreshed = await connectBootstrapWithRetry({
-                serverBaseUrl,
-                userId,
-                agentToken,
-            });
-            natsBootstrap = refreshed.natsBootstrap;
-            pendingTaskIds = refreshed.pendingTaskIds;
-            jetstream = refreshed.jetstream;
-            const refreshedAgentId = typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "";
-            if (!refreshedAgentId) {
-                throw new Error("agent id missing from refreshed bootstrap");
-            }
-            subscribeToFsRpc({
-                jetstream,
-                serverBaseUrl,
-                userId,
-                agentId: refreshedAgentId,
-                agentToken,
-            });
-            subscribeToShellRpc({
-                jetstream,
-                userId,
-                agentId: refreshedAgentId,
-                agentToken,
-            });
-            for (const pendingTaskId of pendingTaskIds) {
-                await waitForAvailableSlot();
-                scheduleTask(async () => {
-                    try {
-                        const task = await claimTaskById({
-                            serverBaseUrl,
-                            userId,
-                            agentToken,
-                            taskId: pendingTaskId,
-                        });
-                        if (task) {
-                            await runClaimedTask({ task, serverBaseUrl, userId, agentToken, jetstream });
-                        }
-                    }
-                    catch (pendingError) {
-                        const pendingMessage = pendingError instanceof Error ? pendingError.message : String(pendingError);
-                        writeAgentError(`pending task refresh failed taskId=${pendingTaskId}: ${pendingMessage}`);
-                    }
-                });
-            }
-            writeAgentInfo(`nats credentials refreshed at=${formatLocalTimestamp()} agentId=${typeof natsBootstrap.agentId === "string" ? natsBootstrap.agentId : "unknown"}`);
-            continue;
-        }
-    }
+    subscribeToRunRpc({
+        jetstream,
+        serverBaseUrl,
+        userId,
+        agentId: initialAgentId,
+        agentToken,
+    });
+    await new Promise(() => {
+        // Keep the long-lived agent process alive for RPC subscriptions and heartbeat.
+    });
 }
 main().catch((error) => {
     const message = error instanceof Error ? error.message : String(error);

package/package.json

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