linkshell-cli 0.5.22 → 0.5.24

package/dist/cli/src/runtime/acp/agent-workspace.js

@@ -1112,6 +1112,109 @@ function parseTimestamp(value) {
     }
     return undefined;
 }
+/** Derive running/idle for a Codex session from its on-disk rollout transcript.
+ *  Codex marks turn boundaries with event_msg payloads: task_started opens a
+ *  turn, task_complete / turn_aborted close it. token_count / response_item
+ *  records trail AFTER task_complete, so we must scan backward to the first
+ *  turn-lifecycle event rather than just looking at the last line. Combined with
+ *  an mtime freshness gate so a process that died mid-turn doesn't stick at
+ *  running. Backward string scan (not split) to avoid materializing every line
+ *  of a possibly-multi-MB rollout. */
+function deriveCodexRolloutStatus(text, mtimeMs, nowMs) {
+    const FRESH_MS = 15_000; // Codex turns can pause between tool calls; a touch wider than Claude's 10s.
+    if (nowMs - mtimeMs >= FRESH_MS)
+        return "idle";
+    let end = text.length;
+    while (end > 0) {
+        const nl = text.lastIndexOf("\n", end - 1);
+        const line = text.slice(nl + 1, end).trim();
+        end = nl;
+        if (!line)
+            continue;
+        let record;
+        try {
+            record = asRecord(JSON.parse(line));
+        }
+        catch {
+            continue; // half-written tail line or non-JSON; keep scanning up.
+        }
+        if (record?.type !== "event_msg")
+            continue;
+        const payloadType = firstString(asRecord(record.payload), ["type"]);
+        if (payloadType === "task_started")
+            return "running";
+        if (payloadType === "task_complete" || payloadType === "turn_aborted")
+            return "idle";
+    }
+    return "idle";
+}
+/** Session ids of Codex rollouts being actively written right now. Codex's
+ *  app-server thread/list reports no live status (and only knows threads THIS
+ *  process owns, not an external `codex` the user is running), so we read it off
+ *  disk like we do for Claude. CPU-frugal: stat every rollout (metadata only)
+ *  but READ only the few whose mtime is fresh — stale files are skipped without
+ *  opening. We add BOTH the filename id and the session_meta.session_id from the
+ *  first line, because a forked/continued rollout's filename id differs from the
+ *  meta id and we don't know which one thread/list reports — covering both makes
+ *  the match robust. Best-effort: any fs error yields an empty set. */
+function runningCodexSessionIds(nowMs) {
+    const running = new Set();
+    const root = join(homedir(), ".codex", "sessions");
+    if (!existsSync(root))
+        return running;
+    const FRESH_MS = 15_000;
+    const ID_RE = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/;
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const path = join(dir, name);
+            let stat;
+            try {
+                stat = statSync(path);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                walk(path);
+                continue;
+            }
+            const match = ID_RE.exec(name);
+            if (!match || !match[1])
+                continue;
+            if (nowMs - stat.mtimeMs >= FRESH_MS)
+                continue; // stale — skip without reading
+            try {
+                const text = readFileSync(path, "utf8");
+                if (deriveCodexRolloutStatus(text, stat.mtimeMs, nowMs) !== "running")
+                    continue;
+                running.add(match[1]); // filename id
+                // Also add the canonical session id from session_meta (first line), which
+                // differs from the filename id for forked/continued rollouts.
+                const firstLine = text.slice(0, text.indexOf("\n") >= 0 ? text.indexOf("\n") : text.length);
+                try {
+                    const metaId = firstString(asRecord(asRecord(JSON.parse(firstLine))?.payload), ["session_id", "id"]);
+                    if (metaId)
+                        running.add(metaId);
+                }
+                catch {
+                    // first line not parseable — filename id already added.
+                }
+            }
+            catch {
+                // Unreadable/raced file — ignore.
+            }
+        }
+    };
+    walk(root);
+    return running;
+}
 function parseRemoteSessions(value) {
     const raw = asRecord(value);
     const sessionsValue = Array.isArray(value) ? value :
@@ -1756,6 +1859,11 @@ export class AgentWorkspaceProxy {
                     activeClient = recovered;
                     result = await activeClient.listSessions();
                 }
+                // Codex's thread/list carries no live status and only knows threads
+                // THIS app-server owns — so an externally-run `codex` shows idle. Read
+                // running state off disk once per sync (CPU-frugal: stats all rollouts,
+                // reads only the fresh few). Claude reports status via parseRemoteSessions.
+                const codexRunning = provider === "codex" ? runningCodexSessionIds(Date.now()) : undefined;
                 for (const remote of parseRemoteSessions(result)) {
                     const agentSessionId = remote.id;
                     // Skip conversations the user explicitly forgot — don't resurrect them.
@@ -1778,18 +1886,19 @@ export class AgentWorkspaceProxy {
                     // conversation, the in-memory status is authoritative — the transcript
                     // lags (the SDK hasn't flushed the in-flight turn to disk), so trusting
                     // it would flicker a live "running" turn back to idle. Otherwise the
-                    // transcript-derived remote.status is authoritative for Claude (it
-                    // reports running/idle straight from disk): surface "running" while an
-                    // external process drives it, and let its "idle" clear a previously
-                    // observed "running" once the external turn finishes. We only fall
-                    // back to the existing status to keep error/waiting_permission sticky
-                    // across a re-sync — deriveTranscriptStatus never emits those, so they
-                    // live only in `existing`; defaulting everything else to idle avoids a
-                    // purely-external session getting stuck at "running" forever.
+                    // transcript-derived running signal is authoritative (Claude reports it
+                    // via remote.status; Codex via the on-disk rollout set): surface
+                    // "running" while an external process drives it, and let it clear once
+                    // the external turn finishes. We only fall back to the existing status
+                    // to keep error/waiting_permission sticky across a re-sync — the
+                    // transcript signals never emit those, so they live only in `existing`;
+                    // defaulting everything else to idle avoids a purely-external session
+                    // getting stuck at "running" forever.
+                    const remoteRunning = remote.status === "running" || (codexRunning?.has(agentSessionId) ?? false);
                     const linkshellDriving = this.currentTurnIds.has(conversationId);
                     const status = linkshellDriving
                         ? existing?.status ?? "running"
-                        : remote.status === "running"
+                        : remoteRunning
                             ? "running"
                             : existing?.status === "error" || existing?.status === "waiting_permission"
                                 ? existing.status
@@ -2045,7 +2154,16 @@ export class AgentWorkspaceProxy {
                 existingConversation.id !== payload.conversationId) {
                 existingConversation = this.adoptConversationId(existingConversation.id, payload.conversationId);
             }
-            if ((this.timelines.get(existingConversation.id) ?? []).length === 0 && existingConversation.status !== "running") {
+            // Hydrate the transcript from disk when we have no timeline yet, UNLESS
+            // LinkShell is itself driving a live turn for this conversation — in that
+            // case the event stream is the source of truth and re-hydrating would be
+            // redundant/racy. We key on currentTurnIds (LinkShell-driving), NOT on
+            // status === "running": an EXTERNALLY-driven session also reports
+            // "running" now (live-status feature) but has no event stream, so gating
+            // on status would skip hydration and leave its timeline stuck empty
+            // ("加载对话记录…" forever).
+            if ((this.timelines.get(existingConversation.id) ?? []).length === 0 &&
+                !this.currentTurnIds.has(existingConversation.id)) {
                 try {
                     const existingAgentSessionId = existingConversation.agentSessionId;
                     let result;