doer-agent 0.3.5 → 0.3.6

package/dist/agent.js

@@ -18,6 +18,7 @@ const codexAuthRpcCodec = StringCodec();
 const settingsRpcCodec = StringCodec();
 const gitRpcCodec = StringCodec();
 const skillRpcCodec = StringCodec();
+const runEventsCodec = StringCodec();
 const retainedRuns = new Map();
 const activeSessionWatchers = new Map();
 const sessionLineIndexCache = new Map();
@@ -30,6 +31,9 @@ function sanitizeUserId(userId) {
 function buildAgentRunRpcSubject(userId, agentId) {
     return `doer.agent.run.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
+function buildAgentRunEventsSubject(userId, agentId) {
+    return `doer.agent.run.events.${sanitizeUserId(userId)}.${agentId.trim()}`;
+}
 function buildAgentSessionRpcSubject(userId, agentId) {
     return `doer.agent.session.rpc.${sanitizeUserId(userId)}.${agentId.trim()}`;
 }
@@ -514,7 +518,7 @@ async function resolveRunStartLockPath(args) {
     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`);
+    return path.join(dir, "pending_new_session.lock");
 }
 async function claimRunStartSlot(args) {
     const lockPath = await resolveRunStartLockPath(args);
@@ -976,34 +980,136 @@ function cloneRunTask(task, _sinceSeq) {
         ...task,
     };
 }
-function extractCodexSessionMetadata(value) {
+function buildImmediateRunChangedEvent(task) {
+    return {
+        type: "run.changed",
+        agentId: task.agentId,
+        sessionId: task.sessionId,
+        filePath: task.sessionFilePath,
+        runId: task.id,
+        updatedAt: task.updatedAt,
+        status: task.status,
+        cancelRequested: task.cancelRequested,
+        resultExitCode: task.resultExitCode,
+        resultSignal: task.resultSignal,
+        error: task.error,
+        finishedAt: task.finishedAt,
+    };
+}
+function publishImmediateRunChangedEvent(args) {
+    args.nc.publish(buildAgentRunEventsSubject(args.userId, args.task.agentId), runEventsCodec.encode(JSON.stringify(buildImmediateRunChangedEvent(args.task))));
+}
+async function findSessionFilePathBySessionId(sessionId) {
+    const targetSessionId = sessionId.trim();
+    if (!targetSessionId) {
+        return null;
+    }
+    let sessionsRootStat;
     try {
-        const parsed = JSON.parse(value);
-        const lineType = typeof parsed.type === "string" ? parsed.type : "";
-        if (!parsed.payload || typeof parsed.payload !== "object" || Array.isArray(parsed.payload)) {
-            return { sessionId: null, sessionFilePath: null };
-        }
-        const payload = parsed.payload;
-        const sessionIdCandidate = typeof payload.sessionId === "string" && payload.sessionId.trim()
-            ? payload.sessionId.trim()
-            : typeof payload.session_id === "string" && payload.session_id.trim()
-                ? payload.session_id.trim()
-                : typeof payload.id === "string" && payload.id.trim() && (lineType === "session_meta" || lineType === "session.started")
-                    ? payload.id.trim()
-                    : null;
-        const filePathCandidate = typeof payload.rollout_path === "string" && payload.rollout_path.trim()
-            ? payload.rollout_path.trim()
-            : typeof payload.filePath === "string" && payload.filePath.trim()
-                ? payload.filePath.trim()
-                : null;
-        return {
-            sessionId: sessionIdCandidate,
-            sessionFilePath: filePathCandidate,
-        };
+        sessionsRootStat = await stat(getSessionsRootPath());
+    }
+    catch {
+        return null;
+    }
+    if (!sessionsRootStat.isDirectory()) {
+        return null;
+    }
+    const files = await collectSessionJsonlFiles(getSessionsRootPath());
+    files.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
+    for (const file of files) {
+        let fileHandle = null;
+        try {
+            fileHandle = await open(file.filePath, "r");
+            const entryStat = await fileHandle.stat();
+            const firstLine = await readFirstLine(fileHandle, entryStat.size);
+            if (!firstLine) {
+                continue;
+            }
+            const parsed = JSON.parse(firstLine);
+            const candidateMeta = parsed && parsed.type === "session_meta" && isObjectRecord(parsed.payload)
+                ? parsed.payload
+                : isObjectRecord(parsed.session_meta)
+                    ? parsed.session_meta
+                    : isObjectRecord(parsed.sessionMeta)
+                        ? parsed.sessionMeta
+                        : isObjectRecord(parsed.meta)
+                            ? parsed.meta
+                            : isObjectRecord(parsed.payload)
+                                ? parsed.payload
+                                : parsed;
+            const candidateId = pickSessionString(candidateMeta.sessionId, candidateMeta.session_id, candidateMeta.id);
+            if (candidateId === targetSessionId) {
+                return file.filePath;
+            }
+        }
+        catch {
+            // ignore malformed session files
+        }
+        finally {
+            await fileHandle?.close().catch(() => undefined);
+        }
+    }
+    return null;
+}
+async function readSessionIdFromSessionFile(filePath) {
+    let fileHandle = null;
+    try {
+        fileHandle = await open(filePath, "r");
+        const entryStat = await fileHandle.stat();
+        const firstLine = await readFirstLine(fileHandle, entryStat.size);
+        if (!firstLine) {
+            return null;
+        }
+        const parsed = JSON.parse(firstLine);
+        const candidateMeta = parsed && parsed.type === "session_meta" && isObjectRecord(parsed.payload)
+            ? parsed.payload
+            : isObjectRecord(parsed.session_meta)
+                ? parsed.session_meta
+                : isObjectRecord(parsed.sessionMeta)
+                    ? parsed.sessionMeta
+                    : isObjectRecord(parsed.meta)
+                        ? parsed.meta
+                        : isObjectRecord(parsed.payload)
+                            ? parsed.payload
+                            : parsed;
+        return pickSessionString(candidateMeta.sessionId, candidateMeta.session_id, candidateMeta.id);
     }
     catch {
-        return { sessionId: null, sessionFilePath: null };
+        return null;
+    }
+    finally {
+        await fileHandle?.close().catch(() => undefined);
+    }
+}
+async function detectPendingRunSession(knownFilePaths) {
+    const sessionsRoot = getSessionsRootPath();
+    let sessionsRootStat;
+    try {
+        sessionsRootStat = await stat(sessionsRoot);
+    }
+    catch {
+        return null;
+    }
+    if (!sessionsRootStat.isDirectory()) {
+        return null;
+    }
+    const files = await collectSessionJsonlFiles(sessionsRoot);
+    files.sort((a, b) => a.mtimeMs - b.mtimeMs || a.filePath.localeCompare(b.filePath));
+    for (const file of files) {
+        if (knownFilePaths.has(file.filePath)) {
+            continue;
+        }
+        const sessionId = await readSessionIdFromSessionFile(file.filePath);
+        if (!sessionId) {
+            continue;
+        }
+        knownFilePaths.add(file.filePath);
+        return {
+            sessionId,
+            sessionFilePath: file.filePath,
+        };
     }
+    return null;
 }
 async function updateRunSessionMetadata(task, metadata) {
     let changed = false;
@@ -1016,11 +1122,25 @@ async function updateRunSessionMetadata(task, metadata) {
         task.sessionFilePath = metadata.sessionFilePath.trim();
         changed = true;
     }
+    if (!task.sessionFilePath && task.sessionId) {
+        const resolvedSessionFilePath = await findSessionFilePathBySessionId(task.sessionId).catch(() => null);
+        if (resolvedSessionFilePath) {
+            task.sessionFilePath = resolvedSessionFilePath;
+            changed = true;
+        }
+    }
     if (!changed) {
         return;
     }
     task.updatedAt = formatLocalTimestamp();
     await persistRunTask(task).catch(() => undefined);
+    if (metadata.nc) {
+        publishImmediateRunChangedEvent({
+            nc: metadata.nc,
+            userId: task.userId,
+            task,
+        });
+    }
     if (!previousSessionId && task.sessionId) {
         await updateRunStartSlotSession({
             runId: task.id,
@@ -1132,46 +1252,60 @@ async function startManagedRun(args) {
         startedAt: now,
         finishedAt: null,
     };
-    let stdoutBuffer = "";
-    const recordChunk = (stream, chunk) => {
-        writeRunStream(task.id, stream, chunk);
-        if (stream !== "stdout" || (task.sessionId && task.sessionFilePath)) {
+    let pendingSessionPollClosed = false;
+    let pendingSessionPollTimer = null;
+    const knownPendingSessionFiles = new Set();
+    const stopPendingSessionPoll = () => {
+        pendingSessionPollClosed = true;
+        if (pendingSessionPollTimer) {
+            clearInterval(pendingSessionPollTimer);
+            pendingSessionPollTimer = null;
+        }
+    };
+    const pollPendingSession = async () => {
+        if (pendingSessionPollClosed || task.sessionId) {
+            stopPendingSessionPoll();
             return;
         }
-        stdoutBuffer += chunk;
-        const lines = stdoutBuffer.split(/\r?\n/);
-        stdoutBuffer = lines.pop() ?? "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed) {
-                continue;
-            }
-            const metadata = extractCodexSessionMetadata(trimmed);
-            if (metadata.sessionId || metadata.sessionFilePath) {
-                void updateRunSessionMetadata(task, metadata);
-            }
+        const detected = await detectPendingRunSession(knownPendingSessionFiles).catch(() => null);
+        if (!detected) {
+            return;
+        }
+        await updateRunSessionMetadata(task, {
+            sessionId: detected.sessionId,
+            sessionFilePath: detected.sessionFilePath,
+            nc: args.nc,
+        }).catch(() => undefined);
+        if (task.sessionId) {
+            stopPendingSessionPoll();
         }
     };
-    child.stdout.on("data", (chunk) => recordChunk("stdout", chunk));
-    child.stderr.on("data", (chunk) => recordChunk("stderr", chunk));
+    if (!task.sessionId) {
+        const existingFiles = await collectSessionJsonlFiles(getSessionsRootPath()).catch(() => []);
+        for (const file of existingFiles) {
+            knownPendingSessionFiles.add(file.filePath);
+        }
+        pendingSessionPollTimer = setInterval(() => {
+            void pollPendingSession();
+        }, 1000);
+    }
+    child.stdout.on("data", (chunk) => writeRunStream(task.id, "stdout", chunk));
+    child.stderr.on("data", (chunk) => writeRunStream(task.id, "stderr", chunk));
     child.once("error", (error) => {
+        stopPendingSessionPoll();
         const message = error instanceof Error ? error.message : String(error);
         task.status = "failed";
         task.error = message;
         task.finishedAt = formatLocalTimestamp();
         persistRetainedRun(task);
+        publishImmediateRunChangedEvent({ nc: args.nc, userId: task.userId, task });
         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", async (code, signal) => {
-        if (stdoutBuffer.trim() && (!task.sessionId || !task.sessionFilePath)) {
-            const metadata = extractCodexSessionMetadata(stdoutBuffer.trim());
-            if (metadata.sessionId || metadata.sessionFilePath) {
-                void updateRunSessionMetadata(task, metadata);
-            }
-        }
+        stopPendingSessionPoll();
         const latest = await getStoredRun(task.id).catch(() => null);
         if (latest?.cancelRequested) {
             task.cancelRequested = true;
@@ -1182,6 +1316,7 @@ async function startManagedRun(args) {
         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);
+        publishImmediateRunChangedEvent({ nc: args.nc, userId: task.userId, task });
         void removeRunTask(task.id).catch(() => undefined);
         void releaseRunStartSlot({ runId: task.id, sessionId: task.sessionId }).catch(() => undefined);
         void prepared.codexAuthCleanup().catch(() => undefined);
@@ -1189,7 +1324,11 @@ async function startManagedRun(args) {
     });
     persistRetainedRun(task);
     void persistRunTask(task).catch(() => undefined);
+    publishImmediateRunChangedEvent({ nc: args.nc, userId: task.userId, task });
     writeRunStatus(task.id, `started requestId=${args.requestId} cwd=${prepared.taskWorkspace}`);
+    if (!task.sessionId) {
+        void pollPendingSession();
+    }
     return cloneRunTask(task);
 }
 function shellSingleQuote(value) {
@@ -2204,6 +2343,7 @@ async function handleRunRpcMessage(args) {
                     serverBaseUrl: args.serverBaseUrl,
                     userId: args.userId,
                     agentId: args.agentId,
+                    nc: args.jetstream.nc,
                     sessionId: request.sessionId,
                     codexArgs: buildManagedCodexArgs({
                         prompt: request.prompt ?? "",
@@ -2253,6 +2393,7 @@ async function handleRunRpcMessage(args) {
             target.cancelRequested = true;
             target.updatedAt = formatLocalTimestamp();
             await persistRunTask(target);
+            publishImmediateRunChangedEvent({ nc: args.jetstream.nc, userId: target.userId, task: target });
             writeRunStatus(target.id, `cancel requested pid=${target.processPid}`);
             sendSignalToPid(target.processPid, "SIGINT");
             const task = cloneRunTask(target);

package/package.json

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