@idl3/claude-control 1.4.5 → 1.4.6

package/lib/sessions.js

@@ -9,6 +9,7 @@
 
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs/promises';
+import { watch as fsWatch } from 'node:fs';
 import path from 'node:path';
 import { execFile as _execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -37,10 +38,16 @@ const CLAUDE_COMM_RE = /(^|\/)claude$/;
 // Matches Codex CLI executable basename.
 const CODEX_COMM_RE = /(^|\/)codex$/;
 const CLAUDE_ARG_RE = /(^|[\s/])claude(?:\s|$)/;
+const LOCAL_WS_RE = /\bws:\/\/(?:127\.0\.0\.1|localhost|\[::1\]|::1):\d+\b/;
 
 function isCodexAppServerArgs(args) {
   const s = String(args || '');
-  return /\bapp-server\b/.test(s) && /\b--listen\b/.test(s);
+  return /\bapp-server\b/.test(s) && /(?:^|\s)--listen(?:[=\s]|$)/.test(s);
+}
+
+function codexAppServerEndpointFromArgs(args) {
+  const m = LOCAL_WS_RE.exec(String(args || ''));
+  return m ? m[0] : null;
 }
 
 // A pane is a Claude Code session when its process title is the Claude version
@@ -87,6 +94,34 @@ export function isCwdConsistent(recCwd, winCwd) {
 
 const PENDING_QUESTION_MAX = 140; // truncate the surfaced question text
 
+// A pane is scraped (capture-pane) by the 2 s thinking poll only while it's
+// "live"; idle backgrounded panes are skipped to cut needless tmux execs. A pane
+// stays live for this long after its transcript last changed.
+const ACTIVE_SCRAPE_WINDOW_MS = 20_000;
+
+/**
+ * Should the 2 s thinking poll scrape this pane? True when:
+ *  - it carries a live flag (thinking/compacting/pending/errored) — keep polling
+ *    until it settles/clears, OR
+ *  - it has no transcript to gate on (can't tell; scrape to be safe), OR
+ *  - its transcript changed recently — via fs.watch (`activeUntilMs`) or the 4 s
+ *    tail read (`lastActivityMs`) as a backstop.
+ * Otherwise it's idle → skip the capture.
+ *
+ * @param {{thinking?:boolean,compacting?:boolean,pending?:boolean,errored?:boolean,transcriptPath?:string|null,lastActivityMs?:number|null}} s
+ * @param {number} activeUntilMs  fs.watch-fed "active until" timestamp for this transcript (0 if none)
+ * @param {number} now
+ * @param {number} windowMs
+ * @returns {boolean}
+ */
+export function shouldScrapePane(s, activeUntilMs, now, windowMs = ACTIVE_SCRAPE_WINDOW_MS) {
+  if (s.thinking || s.compacting || s.pending || s.errored) return true;
+  if (!s.transcriptPath) return true;
+  if (activeUntilMs && now < activeUntilMs) return true;
+  if (s.lastActivityMs && now - s.lastActivityMs < windowMs) return true;
+  return false;
+}
+
 function codexRecordToCandidate(rec) {
   return {
     transcriptPath: rec.transcriptPath,
@@ -406,6 +441,10 @@ export class SessionRegistry extends EventEmitter {
     this._compactingMap = new Map();
     /** @type {Map<string, boolean>} target -> API-error/stall flag */
     this._erroredMap = new Map();
+    /** @type {Map<string, number>} transcriptPath -> "scrape until" ts (fs.watch-fed) */
+    this._activeUntil = new Map();
+    /** @type {Map<string, import('node:fs').FSWatcher>} transcriptPath -> watcher */
+    this._transcriptWatchers = new Map();
     /** @type {Map<string, boolean>} target -> has a sub-agent actively running */
     this._subAgentActiveMap = new Map();
     /** @type {Map<string, {pending:boolean, question:string|null}>} target -> pane-derived prompt */
@@ -707,8 +746,7 @@ export class SessionRegistry extends EventEmitter {
         codexPanes.map(async (p) => {
           try {
             const procInfo = paneProc.get(p.target);
-            if (procInfo?.appServer) appServerTargets.add(p.target);
-            if (appServerTargets.has(p.target) && p.ccTransport !== 'rpc') return;
+            if (procInfo?.appServer || procInfo?.appServerEndpoint) appServerTargets.add(p.target);
 
             const runtimeHint = this._transcriptHintMap.get(p.target);
             if (runtimeHint?.transcriptPath) {
@@ -725,7 +763,10 @@ export class SessionRegistry extends EventEmitter {
 
             const reg = p.paneId ? paneReg.get(p.paneId) : null;
             const codexPid = procInfo?.pid ?? null;
-            if (!codexPid) {
+            if (appServerTargets.has(p.target)) {
+              // App-server processes may hold multiple rollout files for
+              // multiple RPC threads. Only runtime/pane-registry hints are
+              // authoritative enough to bind one back to this tmux pane.
               if (reg?.transcriptPath) {
                 const rec = await readCodexTranscriptRecord(reg.transcriptPath);
                 if (rec && isCwdConsistent(rec.cwd, p.cwd)) {
@@ -738,10 +779,17 @@ export class SessionRegistry extends EventEmitter {
               }
               return;
             }
-            if (appServerTargets.has(p.target)) {
-              // App-server processes may hold multiple rollout files for
-              // multiple RPC threads. Only runtime/pane-registry hints are
-              // authoritative enough to bind one back to this tmux pane.
+            if (!codexPid) {
+              if (reg?.transcriptPath) {
+                const rec = await readCodexTranscriptRecord(reg.transcriptPath);
+                if (rec && isCwdConsistent(rec.cwd, p.cwd)) {
+                  exactByTarget.set(p.target, codexRecordToCandidate({
+                    ...rec,
+                    sessionId: rec.sessionId ?? reg.sessionId ?? null,
+                  }));
+                  exactPaths.add(rec.transcriptPath);
+                }
+              }
               return;
             }
             const rolloutPath = await findOpenRollout(codexPid);
@@ -823,6 +871,17 @@ export class SessionRegistry extends EventEmitter {
       // polled codex model and the rail would show no model for codex rows.
       const ctx = isClaude || kind === 'codex' ? this._ctxMap.get(win.target) || {} : {};
 
+      const procInfo = paneProc.get(win.target);
+      const codexAppServer = kind === 'codex' && (!!procInfo?.appServer || !!procInfo?.appServerEndpoint);
+      const transport = kind === 'claude'
+        ? (win.ccTransport || 'tmux')
+        : kind === 'codex'
+          ? (codexAppServer ? 'rpc' : (win.ccTransport || 'tmux'))
+          : null;
+      const endpoint = kind === 'codex'
+        ? (win.ccEndpoint || procInfo?.appServerEndpoint || null)
+        : (win.ccEndpoint || null);
+
       return {
         id,
         sessionId: transcript?.sessionId ?? null,
@@ -847,8 +906,8 @@ export class SessionRegistry extends EventEmitter {
         cmd: win.cmd,
         isClaude,
         kind,
-        transport: (kind === 'claude' || kind === 'codex') ? (win.ccTransport || 'tmux') : null,
-        endpoint: win.ccEndpoint || null,
+        transport,
+        endpoint,
         ccShell: !!win.ccShell, // a composer >_ sister shell pane
 
         model: ctx.model || prettyModel(transcript?.model) || null,
@@ -865,10 +924,46 @@ export class SessionRegistry extends EventEmitter {
     // Surface EVERY pane: Claude sessions AND plain terminals (each pane is a row;
     // terminals render a live interactive terminal instead of a transcript).
     this._sessions = sessions;
+    this._syncTranscriptWatchers();
     this._maybeEmit();
     return this._sessions;
   }
 
+  /**
+   * Keep one fs.watch per live transcript so a change instantly marks that pane
+   * "active" (scrape-worthy) for the next thinking poll — replacing blanket 2 s
+   * scraping of idle panes. Best-effort: a watch that fails to attach just means
+   * that pane falls back to the lastActivityMs backstop in shouldScrapePane.
+   */
+  _syncTranscriptWatchers() {
+    const wanted = new Set();
+    for (const s of this._sessions) {
+      if (s.transcriptPath) wanted.add(s.transcriptPath);
+    }
+    // Add watchers for new transcripts; seed them active so a freshly-appeared
+    // session is scraped right away, then settles into the gated cadence.
+    for (const p of wanted) {
+      if (this._transcriptWatchers.has(p)) continue;
+      try {
+        const w = fsWatch(p, { persistent: false }, () => {
+          this._activeUntil.set(p, Date.now() + ACTIVE_SCRAPE_WINDOW_MS);
+        });
+        w.on('error', () => {}); // ignore — backstop covers it
+        this._transcriptWatchers.set(p, w);
+        this._activeUntil.set(p, Date.now() + ACTIVE_SCRAPE_WINDOW_MS);
+      } catch {
+        /* unwatchable (gone / FD limit) — lastActivityMs backstop handles it */
+      }
+    }
+    // Drop watchers for transcripts no longer present.
+    for (const [p, w] of this._transcriptWatchers) {
+      if (wanted.has(p)) continue;
+      try { w.close(); } catch { /* ignore */ }
+      this._transcriptWatchers.delete(p);
+      this._activeUntil.delete(p);
+    }
+  }
+
   /**
    * Capture each Claude pane's TUI status line and parse model + context %.
    * Throttled (separate from the 4 s refresh) and best-effort — capture-pane is
@@ -920,6 +1015,11 @@ export class SessionRegistry extends EventEmitter {
         if (!this._tmux.isValidTarget(s.target)) return;
         try {
           if (s.transport === 'print') return;
+          // Skip idle backgrounded panes — only scrape while the pane is live
+          // (flagged) or its transcript changed recently. Cuts capture-pane execs
+          // for sleeping sessions; active/pending/errored panes keep updating.
+          const activeUntil = s.transcriptPath ? this._activeUntil.get(s.transcriptPath) ?? 0 : 0;
+          if (!shouldScrapePane(s, activeUntil, Date.now(), ACTIVE_SCRAPE_WINDOW_MS)) return;
           // Capture the VISIBLE pane only (no scrollback). One capture feeds the
           // working line ("esc to interrupt"), the TUI question picker
           // (parsePanePrompt), and the codex prompt parse. Scrollback MUST be
@@ -1019,6 +1119,11 @@ export class SessionRegistry extends EventEmitter {
       clearInterval(this._thinkingInterval);
       this._thinkingInterval = null;
     }
+    for (const w of this._transcriptWatchers.values()) {
+      try { w.close(); } catch { /* ignore */ }
+    }
+    this._transcriptWatchers.clear();
+    this._activeUntil.clear();
   }
 
   // -------------------------------------------------------------------------
@@ -1105,7 +1210,7 @@ export class SessionRegistry extends EventEmitter {
    * startMs:null} and callers fall back to the cmd heuristic / other passes.
    *
    * @param {import('./tmux.js').Window[]} allPanes
-   * @returns {Promise<Map<string, {isClaude: boolean, isCodex: boolean, kind: string|null, startMs: number|null, appServer?: boolean}>>} target -> info
+   * @returns {Promise<Map<string, {isClaude: boolean, isCodex: boolean, kind: string|null, startMs: number|null, appServer?: boolean, appServerEndpoint?: string|null}>>} target -> info
    */
   async _buildPaneProc(allPanes) {
     const out = new Map();
@@ -1157,13 +1262,15 @@ export class SessionRegistry extends EventEmitter {
           : null;
         if (codexKind) {
           const sec = parseEtime(meta.etime);
+          const appServerEndpoint = codexAppServerEndpointFromArgs(meta.args);
           const codexInfo = {
             isClaude: false,
             isCodex: true,
             kind: 'codex',
             startMs: sec == null ? null : now - sec * 1000,
             pid,
-            appServer: isCodexAppServerArgs(meta.args),
+            appServer: isCodexAppServerArgs(meta.args) || !!appServerEndpoint,
+            appServerEndpoint,
           };
           // npm/nvm installs launch Codex as `node .../bin/codex`, which then
           // spawns the native Codex child. The native child holds the rollout
@@ -1174,11 +1281,11 @@ export class SessionRegistry extends EventEmitter {
         }
         for (const c of children.get(pid) ?? []) queue.push(c);
       }
-      return codexFallback || { isClaude: false, isCodex: false, kind: null, startMs: null, pid: null, appServer: false };
+      return codexFallback || { isClaude: false, isCodex: false, kind: null, startMs: null, pid: null, appServer: false, appServerEndpoint: null };
     };
 
     for (const p of allPanes) {
-      out.set(p.target, p.panePid ? findClaude(p.panePid) : { isClaude: false, isCodex: false, kind: null, startMs: null, pid: null, appServer: false });
+      out.set(p.target, p.panePid ? findClaude(p.panePid) : { isClaude: false, isCodex: false, kind: null, startMs: null, pid: null, appServer: false, appServerEndpoint: null });
     }
     return out;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idl3/claude-control",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "type": "module",
   "description": "Local web UI to watch and drive your Claude Code sessions running in tmux — live transcripts, reply, answer AskUserQuestion, attach files, from a browser or phone.",
   "keywords": [

package/server.js

@@ -1734,12 +1734,15 @@ async function ensureCodexRpcForSession(session) {
   if (existing) return existing;
 
   let capture = '';
-  try {
-    capture = await tmux.capturePane(session.target, 200, false, true);
-  } catch {
-    return null;
+  let endpoint = session.endpoint || null;
+  if (!endpoint) {
+    try {
+      capture = await tmux.capturePane(session.target, 200, false, true);
+    } catch {
+      return null;
+    }
+    endpoint = parseCodexAppServerEndpoint(capture);
   }
-  const endpoint = parseCodexAppServerEndpoint(capture);
   if (!endpoint) {
     if (isCodexAppServerCapture(capture)) {
       throw new Error('Codex RPC app-server endpoint unavailable; refusing to type prompt into tmux pane');