doer-agent 0.2.5 → 0.2.6

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";
@@ -15,7 +15,6 @@ const fsRpcCodec = StringCodec();
 const shellRpcCodec = StringCodec();
 const runRpcCodec = StringCodec();
 const sessionRpcCodec = StringCodec();
-const codexRpcCodec = StringCodec();
 const codexAuthRpcCodec = StringCodec();
 const settingsRpcCodec = StringCodec();
 const gitRpcCodec = StringCodec();
@@ -35,9 +34,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 +417,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 +435,9 @@ function normalizeRunRpcRequest(args) {
         requestId,
         action,
         runId,
-        command,
+        prompt,
+        sessionId,
+        model,
         cwd,
         responseSubject,
         sinceSeq,
@@ -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,6 +1009,13 @@ 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));
@@ -933,11 +1034,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,
@@ -1000,6 +1098,7 @@ async function startManagedRun(args) {
         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}`);
     });
@@ -1019,6 +1118,7 @@ async function startManagedRun(args) {
         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"}`);
     });
@@ -1038,45 +1138,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 +1162,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 +1582,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,20 +1906,32 @@ 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") {
@@ -2458,6 +2506,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 +2847,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 +2867,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 +2957,7 @@ async function getAgentSessionRawRows(args) {
             if (line.trim()) {
                 rawRows.push({
                     id: lineNumber,
-                    raw: line,
+                    raw: sanitizeSessionRpcRawLine(line),
                 });
             }
             lineNumber += 1;
@@ -3805,13 +3938,6 @@ async function main() {
         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.6",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",