@phenx-inc/ctlsurf 0.3.16 → 0.5.0

package/out/headless/index.mjs

@@ -5445,19 +5445,19 @@ var require_addon_serialize = __commonJS({
 // node_modules/electron/index.js
 var require_electron = __commonJS({
   "node_modules/electron/index.js"(exports, module) {
-    var fs2 = __require("fs");
-    var path3 = __require("path");
-    var pathFile = path3.join(__dirname, "path.txt");
+    var fs3 = __require("fs");
+    var path4 = __require("path");
+    var pathFile = path4.join(__dirname, "path.txt");
     function getElectronPath() {
       let executablePath;
-      if (fs2.existsSync(pathFile)) {
-        executablePath = fs2.readFileSync(pathFile, "utf-8");
+      if (fs3.existsSync(pathFile)) {
+        executablePath = fs3.readFileSync(pathFile, "utf-8");
       }
       if (process.env.ELECTRON_OVERRIDE_DIST_PATH) {
-        return path3.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
+        return path4.join(process.env.ELECTRON_OVERRIDE_DIST_PATH, executablePath || "electron");
       }
       if (executablePath) {
-        return path3.join(__dirname, "dist", executablePath);
+        return path4.join(__dirname, "dist", executablePath);
       } else {
         throw new Error("Electron failed to install correctly, please delete node_modules/electron and try installing again");
       }
@@ -5471,7 +5471,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@phenx-inc/ctlsurf",
-      version: "0.3.16",
+      version: "0.5.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: {
@@ -5562,9 +5562,9 @@ function log(...args) {
 }
 
 // src/main/orchestrator.ts
-import path from "path";
-import fs from "fs";
-import os3 from "os";
+import path2 from "path";
+import fs2 from "fs";
+import os4 from "os";
 
 // src/main/pty.ts
 import { createRequire } from "module";
@@ -5700,8 +5700,8 @@ var CtlsurfApi = class {
     }
     return h;
   }
-  async request(method, path3, body) {
-    const url = `${this.baseUrl}${path3}`;
+  async request(method, path4, body) {
+    const url = `${this.baseUrl}${path4}`;
     const opts = {
       method,
       headers: this.headers()
@@ -5712,7 +5712,7 @@ var CtlsurfApi = class {
     const res = await fetch(url, opts);
     if (!res.ok) {
       const text = await res.text();
-      throw new Error(`ctlsurf API ${method} ${path3}: ${res.status} ${text}`);
+      throw new Error(`ctlsurf API ${method} ${path4}: ${res.status} ${text}`);
     }
     return res.json();
   }
@@ -6090,8 +6090,255 @@ function trimToLogLimit(str) {
 ${str.slice(str.length - MAX_LOG_CHARS)}`;
 }
 
-// src/main/workerWs.ts
+// src/main/transcripts.ts
+import fs from "fs";
+import path from "path";
 import os from "os";
+function supportsTranscriptLogging(agentId) {
+  return agentId === "claude" || agentId === "codex";
+}
+var POLL_INTERVAL_MS = 1e3;
+var DISCOVERY_SLACK_MS = 1e4;
+var READ_CHUNK_BYTES = 64 * 1024;
+var MAX_ENTRY_CHARS = 2e4;
+var TranscriptTailer = class {
+  agentId;
+  cwd;
+  sink;
+  claudeProjectsDir;
+  codexSessionsDir;
+  files = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  sinceMs = 0;
+  constructor(options) {
+    this.agentId = options.agentId;
+    this.cwd = stripTrailingSep(options.cwd);
+    this.sink = options.sink;
+    this.claudeProjectsDir = options.claudeProjectsDir || path.join(os.homedir(), ".claude", "projects");
+    this.codexSessionsDir = options.codexSessionsDir || path.join(os.homedir(), ".codex", "sessions");
+  }
+  start() {
+    if (this.pollTimer) return;
+    this.sinceMs = Date.now();
+    this.files.clear();
+    this.pollTimer = setInterval(() => this.poll(), POLL_INTERVAL_MS);
+    console.log(`[transcripts] Tailing ${this.agentId} transcripts for ${this.cwd}`);
+  }
+  stop() {
+    if (!this.pollTimer) return;
+    clearInterval(this.pollTimer);
+    this.pollTimer = null;
+    this.poll();
+    this.files.clear();
+    console.log("[transcripts] Stopped");
+  }
+  poll() {
+    try {
+      this.discover();
+      for (const [filePath, tail] of this.files) {
+        if (!tail.excluded) this.drainFile(filePath, tail);
+      }
+    } catch (err) {
+      console.error("[transcripts] Poll error:", err);
+    }
+  }
+  // ─── Discovery ──────────────────────────────────
+  /**
+   * Track every transcript file with recent activity, not just the first
+   * match: /clear (Claude) or /new (Codex) starts a new session file in the
+   * middle of one PTY run, and tailing all active candidates handles the
+   * switch without special cases. Old idle files never match (stale mtime).
+   */
+  discover() {
+    const dirs = this.agentId === "claude" ? [this.claudeProjectsDirForCwd()] : this.codexDateDirs();
+    for (const dir of dirs) {
+      let names;
+      try {
+        names = fs.readdirSync(dir);
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (!name.endsWith(".jsonl")) continue;
+        if (this.agentId === "codex" && !name.startsWith("rollout-")) continue;
+        const filePath = path.join(dir, name);
+        if (this.files.has(filePath)) continue;
+        try {
+          const stat = fs.statSync(filePath);
+          if (stat.mtimeMs >= this.sinceMs - DISCOVERY_SLACK_MS) {
+            this.files.set(filePath, { offset: 0, remainder: "", excluded: false });
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  claudeProjectsDirForCwd() {
+    const slug = this.cwd.replace(/[^a-zA-Z0-9]/g, "-");
+    return path.join(this.claudeProjectsDir, slug);
+  }
+  codexDateDirs() {
+    const dirs = /* @__PURE__ */ new Set();
+    for (const ms of [this.sinceMs, Date.now()]) {
+      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(this.codexSessionsDir, yyyy, mm, dd));
+    }
+    return [...dirs];
+  }
+  // ─── Tailing ────────────────────────────────────
+  drainFile(filePath, tail) {
+    let size;
+    try {
+      size = fs.statSync(filePath).size;
+    } catch {
+      return;
+    }
+    if (size <= tail.offset) return;
+    let fd;
+    try {
+      fd = fs.openSync(filePath, "r");
+    } catch {
+      return;
+    }
+    try {
+      const buf = Buffer.alloc(READ_CHUNK_BYTES);
+      while (tail.offset < size && !tail.excluded) {
+        const bytesRead = fs.readSync(fd, buf, 0, READ_CHUNK_BYTES, tail.offset);
+        if (bytesRead <= 0) break;
+        tail.offset += bytesRead;
+        tail.remainder += buf.toString("utf-8", 0, bytesRead);
+        const lines = tail.remainder.split("\n");
+        tail.remainder = lines.pop() || "";
+        for (const line of lines) {
+          this.handleLine(line, tail);
+          if (tail.excluded) break;
+        }
+      }
+    } catch (err) {
+      console.error(`[transcripts] Read error for ${filePath}:`, err);
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  handleLine(line, tail) {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    const entry = this.agentId === "claude" ? this.parseClaudeLine(obj) : this.parseCodexLine(obj, tail);
+    if (!entry) return;
+    const ms = Date.parse(entry.ts);
+    if (Number.isFinite(ms) && ms < this.sinceMs - DISCOVERY_SLACK_MS) return;
+    this.sink({ ...entry, content: capLength(entry.content) });
+  }
+  // ─── Claude Code format ─────────────────────────
+  parseClaudeLine(obj) {
+    if (!obj || typeof obj !== "object") return null;
+    if (obj.isMeta) return null;
+    if (obj.type !== "user" && obj.type !== "assistant") return null;
+    if (typeof obj.cwd === "string" && stripTrailingSep(obj.cwd) !== this.cwd) return null;
+    if (obj.isSidechain) return null;
+    const message = obj.message;
+    if (!message) return null;
+    const text = extractClaudeText(message.content, obj.type === "user");
+    if (!text) return null;
+    return {
+      ts: typeof obj.timestamp === "string" ? obj.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      type: obj.type === "user" ? "user_input" : "terminal_output",
+      content: text
+    };
+  }
+  // ─── Codex CLI format ───────────────────────────
+  parseCodexLine(obj, tail) {
+    if (!obj || typeof obj !== "object") return null;
+    const payload = obj.payload;
+    if (obj.type === "session_meta") {
+      const metaCwd = payload?.cwd;
+      if (typeof metaCwd === "string" && stripTrailingSep(metaCwd) !== this.cwd) {
+        tail.excluded = true;
+      }
+      return null;
+    }
+    if (obj.type !== "event_msg" || !payload || typeof payload !== "object") return null;
+    let type;
+    if (payload.type === "user_message") {
+      type = "user_input";
+    } else if (payload.type === "agent_message") {
+      type = "terminal_output";
+    } else {
+      return null;
+    }
+    const text = typeof payload.message === "string" ? payload.message.trim() : "";
+    if (!text || isCodexNoise(text)) return null;
+    return {
+      ts: typeof obj.timestamp === "string" ? obj.timestamp : (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      content: text
+    };
+  }
+};
+var CLAUDE_NOISE_PREFIXES = [
+  "<local-command-caveat>",
+  "<command-name>",
+  "<command-message>",
+  "<local-command-stdout>",
+  "<bash-input>",
+  "<bash-stdout>",
+  "<bash-stderr>",
+  "<system-reminder>",
+  "<task-notification>",
+  "caveat: the messages below",
+  "[request interrupted"
+];
+var CODEX_NOISE_PREFIXES = [
+  "<environment_context>",
+  "<user_instructions>",
+  "<permissions instructions>",
+  "<turn_aborted>"
+];
+function isClaudeNoise(text) {
+  const lower = text.trimStart().toLowerCase();
+  return CLAUDE_NOISE_PREFIXES.some((p) => lower.startsWith(p));
+}
+function isCodexNoise(text) {
+  const lower = text.trimStart().toLowerCase();
+  return CODEX_NOISE_PREFIXES.some((p) => lower.startsWith(p));
+}
+function extractClaudeText(content, isUser) {
+  if (typeof content === "string") {
+    const text = content.trim();
+    return text && !isClaudeNoise(text) ? text : "";
+  }
+  if (!Array.isArray(content)) return "";
+  if (isUser && content.some((b) => b?.type === "tool_result")) return "";
+  const parts = [];
+  for (const block of content) {
+    if (block?.type !== "text" || typeof block.text !== "string") continue;
+    const text = block.text.trim();
+    if (text && !isClaudeNoise(text)) parts.push(text);
+  }
+  return parts.join("\n\n");
+}
+function stripTrailingSep(p) {
+  return p.length > 1 ? p.replace(/[/\\]+$/, "") : p;
+}
+function capLength(str) {
+  if (str.length <= MAX_ENTRY_CHARS) return str;
+  return str.slice(0, MAX_ENTRY_CHARS) + `\u2026 [truncated, ${str.length} total chars]`;
+}
+
+// src/main/workerWs.ts
+import os2 from "os";
 import crypto from "crypto";
 import WsModule from "ws";
 var WS = typeof WebSocket !== "undefined" ? WebSocket : WsModule;
@@ -6131,7 +6378,7 @@ var WorkerWsClient = class {
   // single worker server-side. cwd is included so the same folder maps to the
   // same worker across restarts.
   generateFingerprint(cwd) {
-    const data = `${os.hostname()}:${os.userInfo().username}:${os.platform()}:${os.arch()}:${cwd}`;
+    const data = `${os2.hostname()}:${os2.userInfo().username}:${os2.platform()}:${os2.arch()}:${cwd}`;
     return crypto.createHash("sha256").update(data).digest("hex").slice(0, 32);
   }
   setStatus(status) {
@@ -6340,7 +6587,7 @@ var WorkerWsClient = class {
 };
 
 // src/main/timeTracker.ts
-import os2 from "os";
+import os3 from "os";
 import { randomUUID } from "crypto";
 var DATASTORE_TITLE = "Time Tracking";
 var AGENT_DATASTORE_PAGE_TITLE = "Agent Datastore";
@@ -6445,7 +6692,7 @@ var TimeTracker = class {
         "Active Time": Math.round(s.activeMs / 6e4),
         "Last Updated": (/* @__PURE__ */ new Date()).toISOString(),
         Agent: s.agentName,
-        Worker: os2.hostname(),
+        Worker: os3.hostname(),
         Session: s.sessionUuid,
         Notes: ""
       });
@@ -6884,6 +7131,7 @@ var Orchestrator = class {
   noProjectPollTimer = null;
   noProjectPollCwd = null;
   currentProjectName = null;
+  transcriptTailer = null;
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
@@ -6935,11 +7183,36 @@ var Orchestrator = class {
     this.saveSettings();
     this.bridge.setLoggingEnabled(enabled);
     if (!enabled) {
-      this.bridge.endSession();
+      this.stopChatLogging();
     } else if (this.activeTabId) {
+      const tab = this.tabs.get(this.activeTabId);
+      if (tab) this.startChatLogging(tab.agent, tab.cwd);
+    }
+  }
+  // Agents with native session transcripts (Claude Code, Codex) get exact
+  // chat text tailed from their JSONL logs; everything else falls back to
+  // the terminal screen-scraper bridge.
+  startChatLogging(agent, cwd) {
+    this.stopChatLogging();
+    if (!this.settings.logChat) return;
+    if (supportsTranscriptLogging(agent.id)) {
+      this.transcriptTailer = new TranscriptTailer({
+        agentId: agent.id,
+        cwd,
+        sink: (entry) => this.workerWs.sendChatLog(entry)
+      });
+      this.transcriptTailer.start();
+    } else {
       this.bridge.startSession();
     }
   }
+  stopChatLogging() {
+    if (this.transcriptTailer) {
+      this.transcriptTailer.stop();
+      this.transcriptTailer = null;
+    }
+    this.bridge.endSession();
+  }
   // ─── Settings ───────────────────────────────────
   getActiveProfile() {
     return this.settings.profiles[this.settings.activeProfile] || this.settings.profiles.production || DEFAULT_PROFILES.production;
@@ -6989,13 +7262,13 @@ var Orchestrator = class {
   }
   loadSettings() {
     try {
-      fs.mkdirSync(this.settingsDir, { recursive: true });
+      fs2.mkdirSync(this.settingsDir, { recursive: true });
     } catch {
     }
-    const settingsPath = path.join(this.settingsDir, "settings.json");
+    const settingsPath = path2.join(this.settingsDir, "settings.json");
     try {
-      if (fs.existsSync(settingsPath)) {
-        const raw = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+      if (fs2.existsSync(settingsPath)) {
+        const raw = JSON.parse(fs2.readFileSync(settingsPath, "utf-8"));
         if (!raw.profiles) {
           this.settings = {
             activeProfile: "production",
@@ -7032,10 +7305,10 @@ var Orchestrator = class {
     this.bridge.setLoggingEnabled(!!this.settings.logChat);
   }
   saveSettings() {
-    const settingsPath = path.join(this.settingsDir, "settings.json");
+    const settingsPath = path2.join(this.settingsDir, "settings.json");
     try {
-      fs.mkdirSync(this.settingsDir, { recursive: true });
-      fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
+      fs2.mkdirSync(this.settingsDir, { recursive: true });
+      fs2.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
     } catch (err) {
       log("[settings] Failed to save:", err.message);
     }
@@ -7151,7 +7424,7 @@ var Orchestrator = class {
       this.events.onPtyExit(tabId, exitCode);
       await this.timeTracker.endSession(tabId);
       if (tabId === this.activeTabId) {
-        this.bridge.endSession();
+        this.stopChatLogging();
         if (this.currentAgent && isCodingAgent(this.currentAgent)) {
           this.workerWs.disconnect();
         }
@@ -7159,9 +7432,7 @@ var Orchestrator = class {
       const t = this.tabs.get(tabId);
       if (t?.termStreamTimer) clearTimeout(t.termStreamTimer);
     });
-    if (this.settings.logChat) {
-      this.bridge.startSession();
-    }
+    this.startChatLogging(agent, cwd);
     const profile = this.getActiveProfile();
     const shouldTrack = opts?.trackTime !== void 0 ? opts.trackTime : profile.trackTime !== false;
     if (shouldTrack) {
@@ -7201,7 +7472,7 @@ var Orchestrator = class {
     tab.ptyManager.kill();
     this.tabs.delete(tabId);
     if (tabId === this.activeTabId) {
-      this.bridge.endSession();
+      this.stopChatLogging();
       if (isCodingAgent(tab.agent)) {
         this.workerWs.disconnect();
       }
@@ -7282,7 +7553,7 @@ var Orchestrator = class {
     }
     this.stopNoProjectPolling();
     this.workerWs.connect({
-      machine: os3.hostname(),
+      machine: os4.hostname(),
       cwd,
       agent: agent.name
     });
@@ -7352,7 +7623,7 @@ var Orchestrator = class {
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
     this.stopNoProjectPolling();
-    this.bridge.endSession();
+    this.stopChatLogging();
     await this.timeTracker.endAll();
     for (const [, tab] of this.tabs) {
       if (tab.termStreamTimer) clearTimeout(tab.termStreamTimer);
@@ -7364,18 +7635,18 @@ var Orchestrator = class {
 };
 
 // src/main/settingsDir.ts
-import path2 from "path";
-import os4 from "os";
+import path3 from "path";
+import os5 from "os";
 function getSettingsDir(useElectron) {
   if (useElectron) {
     const { app } = require_electron();
     return app.getPath("userData");
   }
   if (process.platform === "darwin") {
-    return path2.join(os4.homedir(), "Library", "Application Support", "ctlsurf-worker");
+    return path3.join(os5.homedir(), "Library", "Application Support", "ctlsurf-worker");
   }
-  return path2.join(
-    process.env.XDG_CONFIG_HOME || path2.join(os4.homedir(), ".config"),
+  return path3.join(
+    process.env.XDG_CONFIG_HOME || path3.join(os5.homedir(), ".config"),
     "ctlsurf-worker"
   );
 }