@phenx-inc/ctlsurf 0.8.0 → 0.10.0

package/out/headless/index.mjs

@@ -5471,7 +5471,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.8.0",
+      version: "0.10.0",
       description: "Agent-agnostic terminal and desktop app for ctlsurf \u2014 run Claude Code, Codex, or any coding agent with live session logging and remote control",
       main: "out/main/index.js",
       bin: {
@@ -6337,6 +6337,320 @@ function capLength(str) {
   if (str.length <= MAX_ENTRY_CHARS) return str;
   return str.slice(0, MAX_ENTRY_CHARS) + `\u2026 [truncated, ${str.length} total chars]`;
 }
+function readLatestAssistantReply(opts) {
+  try {
+    const cwd = stripTrailingSep(opts.cwd);
+    if (opts.agentId === "claude") {
+      const file = mostRecentClaudeFile(cwd, opts.claudeProjectsDir);
+      if (!file) return null;
+      const text = lastClaudeAssistant(file, cwd);
+      return text ? capLength(text) : null;
+    }
+    const codexRoot = opts.codexSessionsDir || path.join(os.homedir(), ".codex", "sessions");
+    for (const file of recentCodexRollouts(codexRoot)) {
+      const text = lastCodexAgentMessage(file, cwd);
+      if (text) return capLength(text);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function readLines(file) {
+  try {
+    return fs.readFileSync(file, "utf-8").split("\n");
+  } catch {
+    return [];
+  }
+}
+function mostRecentClaudeFile(cwd, root) {
+  const projectsRoot = root || path.join(os.homedir(), ".claude", "projects");
+  const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-");
+  const dir = path.join(projectsRoot, slug);
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  let best = null;
+  let bestMs = -Infinity;
+  for (const name of names) {
+    if (!name.endsWith(".jsonl")) continue;
+    const fp = path.join(dir, name);
+    try {
+      const ms = fs.statSync(fp).mtimeMs;
+      if (ms > bestMs) {
+        bestMs = ms;
+        best = fp;
+      }
+    } catch {
+    }
+  }
+  return best;
+}
+function recentCodexRollouts(root) {
+  const dirs = /* @__PURE__ */ new Set();
+  const now = Date.now();
+  for (const ms of [now, now - 24 * 60 * 60 * 1e3]) {
+    const d = new Date(ms);
+    const yyyy = String(d.getFullYear());
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    dirs.add(path.join(root, yyyy, mm, dd));
+  }
+  const files = [];
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      if (!name.startsWith("rollout-") || !name.endsWith(".jsonl")) continue;
+      const fp = path.join(dir, name);
+      try {
+        files.push({ fp, ms: fs.statSync(fp).mtimeMs });
+      } catch {
+      }
+    }
+  }
+  return files.sort((a, b) => b.ms - a.ms).map((f) => f.fp);
+}
+function lastClaudeAssistant(file, cwd) {
+  const lines = readLines(file);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    if (obj.isMeta || obj.isSidechain || obj.type !== "assistant") continue;
+    if (typeof obj.cwd === "string" && stripTrailingSep(obj.cwd) !== cwd) continue;
+    const text = extractClaudeText(obj.message?.content, false);
+    if (text) return text;
+  }
+  return null;
+}
+function lastCodexAgentMessage(file, cwd) {
+  const lines = readLines(file);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (obj?.type === "session_meta") {
+      const metaCwd = obj.payload?.cwd;
+      if (typeof metaCwd === "string" && stripTrailingSep(metaCwd) !== cwd) return null;
+      break;
+    }
+  }
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const trimmed = lines[i].trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (obj?.type !== "event_msg" || obj.payload?.type !== "agent_message") continue;
+    const text = typeof obj.payload.message === "string" ? obj.payload.message.trim() : "";
+    if (text && !isCodexNoise(text)) return text;
+  }
+  return null;
+}
+
+// src/main/agentState.ts
+var BUSY_GRACE_MS = 2500;
+var SETTLE_MS = 1200;
+var DECISION_TTL_MS = 4e3;
+var TICK_MS = 400;
+var HOOK_AUTHORITY_MS = 6e3;
+var TAIL_KEEP_CHARS = 240;
+var CLAUDE_SPINNER = /[✶✻✳✺✢✷✸✹❋][^\n]{0,60}(?:…|\.\.\.)/;
+function hasBusyMarker(text) {
+  return /esc to interrupt/i.test(text) || /\bWorking \(\d+s/i.test(text) || CLAUDE_SPINNER.test(text);
+}
+var APPROVAL_PATTERNS = [
+  /\bDo you want to (proceed|continue|create|make this edit|run)\b/i,
+  // Claude Code
+  /❯\s*\d+\.\s*Yes\b/i,
+  // Claude numbered-choice prompt
+  /\bAllow command\b/i,
+  // Codex
+  /\bRun this command\?/i,
+  // Codex
+  /\bApprove\b[^\n]*\?/i,
+  /\(y\/n\)/i,
+  /\[y\/N\]/i
+];
+function hasApprovalMarker(text) {
+  return APPROVAL_PATTERNS.some((re) => re.test(text));
+}
+function stripAnsi2(str) {
+  return str.replace(/\x1b\[[\x30-\x3f]*[\x20-\x2f]*[\x40-\x7e]/g, "").replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, "").replace(/\x1b/g, "");
+}
+var AgentStateMonitor = class {
+  sink;
+  now;
+  tabs = /* @__PURE__ */ new Map();
+  timer = null;
+  lastAnyAwaiting = false;
+  constructor(sink, now = Date.now) {
+    this.sink = sink;
+    this.now = now;
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.tick(), TICK_MS);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.tabs.clear();
+    this.lastAnyAwaiting = false;
+  }
+  /** Register a tab so its raw PTY output can be classified. */
+  trackTab(tabId, agentId, cwd) {
+    const now = this.now();
+    this.tabs.set(tabId, {
+      agentId,
+      cwd,
+      state: "idle",
+      everBusy: false,
+      lastBusyAt: 0,
+      lastOutputAt: now,
+      lastDecisionAt: 0,
+      hookState: null,
+      hookAt: 0,
+      tail: ""
+    });
+  }
+  removeTab(tabId) {
+    if (this.tabs.delete(tabId)) this.emitAggregate();
+  }
+  /** Feed a raw PTY output chunk for a tab. */
+  feed(tabId, data) {
+    const rec = this.tabs.get(tabId);
+    if (!rec) return;
+    const now = this.now();
+    rec.lastOutputAt = now;
+    const text = rec.tail + stripAnsi2(data);
+    rec.tail = text.length > TAIL_KEEP_CHARS ? text.slice(-TAIL_KEEP_CHARS) : text;
+    if (hasBusyMarker(text)) {
+      rec.lastBusyAt = now;
+      rec.everBusy = true;
+    }
+    if (hasApprovalMarker(text)) {
+      rec.lastDecisionAt = now;
+    }
+  }
+  /**
+   * Note input written to a tab's PTY. Only a *submit* (data containing a
+   * newline) counts as the user engaging — clearing any awaiting state and
+   * resetting the "has worked" flag so a leftover idle box doesn't re-flag.
+   *
+   * Individual keystrokes and, crucially, the terminal's own auto-responses
+   * (cursor-position / device-attribute replies that TUIs constantly trigger,
+   * which xterm.js writes straight back to the PTY) are ignored — otherwise
+   * the state would churn busy↔idle on every control-sequence handshake.
+   */
+  noteInput(tabId, data) {
+    if (!/[\r\n]/.test(data)) return;
+    const rec = this.tabs.get(tabId);
+    if (!rec) return;
+    const now = this.now();
+    rec.everBusy = false;
+    rec.lastBusyAt = now;
+    rec.lastDecisionAt = 0;
+    rec.hookState = null;
+    this.setState(rec, tabId, "busy");
+  }
+  /**
+   * Apply an authoritative state from an agent hook, addressed by cwd. Overrides
+   * the heuristic for HOOK_AUTHORITY_MS. `kind`:
+   *   'awaiting_input'    — turn done / idle prompt (Stop, idle_prompt, agent-turn-complete)
+   *   'awaiting_decision' — permission/approval prompt (PermissionRequest, permission_prompt)
+   *   'busy'              — user submitted a prompt (UserPromptSubmit)
+   */
+  applyHookEvent(cwd, kind) {
+    const target = stripTrailingSep2(cwd);
+    const now = this.now();
+    for (const [tabId, rec] of this.tabs) {
+      if (stripTrailingSep2(rec.cwd) !== target) continue;
+      rec.hookState = kind;
+      rec.hookAt = now;
+      if (kind === "busy") {
+        rec.everBusy = false;
+        rec.lastBusyAt = now;
+      }
+      this.setState(rec, tabId, kind);
+    }
+  }
+  tick() {
+    const now = this.now();
+    for (const [tabId, rec] of this.tabs) {
+      if (rec.hookState && now - rec.hookAt < HOOK_AUTHORITY_MS) {
+        this.setState(rec, tabId, rec.hookState);
+        continue;
+      }
+      const busyRecently = rec.lastBusyAt > 0 && now - rec.lastBusyAt < BUSY_GRACE_MS;
+      const settled = now - rec.lastOutputAt >= SETTLE_MS;
+      const decisionRecent = rec.lastDecisionAt > 0 && now - rec.lastDecisionAt < DECISION_TTL_MS;
+      let next = null;
+      if (busyRecently) {
+        next = "busy";
+      } else if (settled && rec.everBusy) {
+        next = rec.state === "awaiting_decision" || decisionRecent ? "awaiting_decision" : "awaiting_input";
+      } else if (settled && !rec.everBusy) {
+        next = "idle";
+      }
+      if (next) this.setState(rec, tabId, next);
+    }
+    this.emitAggregate();
+  }
+  setState(rec, tabId, state) {
+    if (rec.state === state) return;
+    rec.state = state;
+    this.sink({ tabId, state, anyAwaiting: this.computeAnyAwaiting() });
+    this.lastAnyAwaiting = this.computeAnyAwaiting();
+  }
+  emitAggregate() {
+    const anyAwaiting = this.computeAnyAwaiting();
+    if (anyAwaiting === this.lastAnyAwaiting) return;
+    this.lastAnyAwaiting = anyAwaiting;
+    const tabId = this.firstAwaitingTabId() ?? "";
+    const state = tabId ? this.tabs.get(tabId).state : "idle";
+    this.sink({ tabId, state, anyAwaiting });
+  }
+  computeAnyAwaiting() {
+    for (const rec of this.tabs.values()) {
+      if (rec.state === "awaiting_input" || rec.state === "awaiting_decision") return true;
+    }
+    return false;
+  }
+  firstAwaitingTabId() {
+    for (const [tabId, rec] of this.tabs) {
+      if (rec.state === "awaiting_input" || rec.state === "awaiting_decision") return tabId;
+    }
+    return null;
+  }
+};
+function stripTrailingSep2(p) {
+  return p.length > 1 ? p.replace(/[/\\]+$/, "") : p;
+}
 
 // src/main/workerWs.ts
 import os2 from "os";
@@ -7133,9 +7447,14 @@ var Orchestrator = class {
   noProjectPollCwd = null;
   currentProjectName = null;
   transcriptTailer = null;
+  stateMonitor;
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
+    this.stateMonitor = new AgentStateMonitor(({ tabId, state, anyAwaiting }) => {
+      this.events.onAgentStateChange?.(tabId, state, anyAwaiting);
+    });
+    this.stateMonitor.start();
     this.workerWs = new WorkerWsClient({
       onStatusChange: (status) => {
         log(`[worker-ws] Status: ${status}`);
@@ -7147,9 +7466,10 @@ var Orchestrator = class {
         this.workerWs.sendAck(message.id);
         if (message.type === "prompt" || message.type === "task_dispatch") {
           const activeTab = this.activeTabId ? this.tabs.get(this.activeTabId) : null;
-          if (activeTab) {
+          if (activeTab && this.activeTabId) {
             activeTab.ptyManager.write(message.content + "\r");
             this.bridge.feedInput(message.content + "\r");
+            this.stateMonitor.noteInput(this.activeTabId, message.content + "\r");
           }
         }
       },
@@ -7182,6 +7502,17 @@ var Orchestrator = class {
   get speakRepliesEnabled() {
     return !!this.settings.speakReplies;
   }
+  // Latest assistant reply from a tab's transcript, for on-demand "read aloud".
+  // Defaults to the active tab. Returns null when the tab's agent has no native
+  // transcript (only Claude Code / Codex do) or nothing has been said yet. Reads
+  // the transcript directly, so it works regardless of the speakReplies setting.
+  getLastReply(tabId) {
+    const id = tabId || this.activeTabId;
+    if (!id) return null;
+    const tab = this.tabs.get(id);
+    if (!tab || !supportsTranscriptLogging(tab.agent.id)) return null;
+    return readLatestAssistantReply({ agentId: tab.agent.id, cwd: tab.cwd });
+  }
   setLogChat(enabled) {
     this.settings.logChat = enabled;
     this.saveSettings();
@@ -7429,9 +7760,11 @@ var Orchestrator = class {
     const ptyManager = new PtyManager(agent, cwd);
     const tab = { ptyManager, agent, cwd, termStreamBuffer: "", termStreamTimer: null };
     this.tabs.set(tabId, tab);
+    this.stateMonitor.trackTab(tabId, agent.id, cwd);
     ptyManager.onData((data) => {
       this.events.onPtyData(tabId, data);
       this.timeTracker.recordActivity(tabId);
+      this.stateMonitor.feed(tabId, data);
       if (tabId === this.activeTabId) {
         this.bridge.feedOutput(data);
         this.streamTerminalData(tabId, data);
@@ -7448,6 +7781,7 @@ var Orchestrator = class {
       }
       const t = this.tabs.get(tabId);
       if (t?.termStreamTimer) clearTimeout(t.termStreamTimer);
+      this.stateMonitor.removeTab(tabId);
     });
     this.startChatLogging(agent, cwd);
     const profile = this.getActiveProfile();
@@ -7470,6 +7804,7 @@ var Orchestrator = class {
   }
   writePty(tabId, data) {
     this.tabs.get(tabId)?.ptyManager.write(data);
+    this.stateMonitor.noteInput(tabId, data);
     if (tabId === this.activeTabId) {
       this.bridge.feedInput(data);
     }
@@ -7488,6 +7823,7 @@ var Orchestrator = class {
     await this.timeTracker.endSession(tabId);
     tab.ptyManager.kill();
     this.tabs.delete(tabId);
+    this.stateMonitor.removeTab(tabId);
     if (tabId === this.activeTabId) {
       this.stopChatLogging();
       if (isCodingAgent(tab.agent)) {
@@ -7641,6 +7977,7 @@ var Orchestrator = class {
   async shutdown() {
     this.stopNoProjectPolling();
     this.stopChatLogging();
+    this.stateMonitor.stop();
     await this.timeTracker.endAll();
     for (const [, tab] of this.tabs) {
       if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);