@phenx-inc/ctlsurf 0.8.0 → 0.10.0

package/out/renderer/assets/{tsMode-yAjlPR-D.js → tsMode-Dqd8vdLE.js}

@@ -1,4 +1,4 @@
-import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index---H6cxNl.js";
+import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-Dg1vMspf.js";
 class WorkerManager {
   constructor(_modeId, _defaults) {
     this._modeId = _modeId;

package/out/renderer/assets/{typescript-BiJRCUcL.js → typescript-Dysz1PTX.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index---H6cxNl.js";
+import { l as languages } from "./index-Dg1vMspf.js";
 const conf = {
   wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
   comments: {

package/out/renderer/assets/{xml-D4PvYeQq.js → xml-BHp5Z9nc.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index---H6cxNl.js";
+import { l as languages } from "./index-Dg1vMspf.js";
 const conf = {
   comments: {
     blockComment: ["<!--", "-->"]

package/out/renderer/assets/{yaml-BeHVkmnS.js → yaml-CPDHxVup.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index---H6cxNl.js";
+import { l as languages } from "./index-Dg1vMspf.js";
 const conf = {
   comments: {
     lineComment: "#"

package/out/renderer/index.html

@@ -4,10 +4,72 @@
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>ctlsurf-worker</title>
-  <script type="module" crossorigin src="./assets/index---H6cxNl.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-B-iM7dFC.css">
+  <!-- Boot splash styles are inlined here so they paint on the first frame,
+       before the JS bundle and styles.css have loaded. Without this the window
+       shows an empty dark pane while React mounts and the startup IPC runs. -->
+  <style>
+    #boot-splash {
+      position: fixed;
+      inset: 0;
+      z-index: 9999;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      gap: 16px;
+      background: #1a1b26;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      transition: opacity 0.3s ease;
+      -webkit-app-region: drag; /* keep the frameless window draggable during load */
+    }
+    #boot-splash.boot-splash-hidden {
+      opacity: 0;
+      pointer-events: none;
+    }
+    .boot-spinner {
+      width: 34px;
+      height: 34px;
+      border-radius: 50%;
+      border: 3px solid rgba(122, 162, 247, 0.22);
+      border-top-color: #7aa2f7;
+      animation: boot-spin 0.8s linear infinite;
+    }
+    @keyframes boot-spin {
+      to { transform: rotate(360deg); }
+    }
+    .boot-splash-title {
+      font-size: 15px;
+      font-weight: 600;
+      letter-spacing: 0.02em;
+      color: #c0caf5;
+    }
+    .boot-splash-label {
+      font-size: 12px;
+      letter-spacing: 0.04em;
+      color: #565f89;
+    }
+  </style>
+  <script type="module" crossorigin src="./assets/index-Dg1vMspf.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-BIceGcz3.css">
 </head>
 <body>
+  <div id="boot-splash">
+    <div class="boot-spinner"></div>
+    <div class="boot-splash-title">ctlsurf</div>
+    <div class="boot-splash-label">Starting up…</div>
+  </div>
   <div id="root"></div>
+  <script>
+    // Fades out and removes the boot splash. Called by the React app once its
+    // startup IPC has settled (see App.tsx). The timeout is a safety net so a
+    // hung startup never leaves the user stuck behind the splash forever.
+    window.__dismissSplash = function () {
+      var el = document.getElementById('boot-splash')
+      if (!el) return
+      el.classList.add('boot-splash-hidden')
+      setTimeout(function () { el.remove() }, 350)
+    }
+    setTimeout(function () { window.__dismissSplash() }, 10000)
+  </script>
 </body>
 </html>

package/out/repro-toggle.mjs

@@ -0,0 +1,305 @@
+// repro-toggle.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+
+// src/main/transcripts.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+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 line2 of lines) {
+          this.handleLine(line2, tail);
+          if (tail.excluded) break;
+        }
+      }
+    } catch (err) {
+      console.error(`[transcripts] Read error for ${filePath}:`, err);
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+  handleLine(line2, tail) {
+    const trimmed = line2.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]`;
+}
+
+// repro-toggle.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var line = (o) => JSON.stringify(o) + "\n";
+var tmp = fs2.mkdtempSync(path2.join(os2.tmpdir(), "toggle-test-"));
+var claudeDir = path2.join(tmp, "claude-projects");
+var cwd = "/Users/test/projects/my_app";
+var projDir = path2.join(claudeDir, "-Users-test-projects-my-app");
+fs2.mkdirSync(projDir, { recursive: true });
+var sessionFile = path2.join(projDir, "session-1.jsonl");
+var era = "enable#1";
+var emitted = [];
+var sink = (e) => emitted.push({ era, type: e.type, content: e.content });
+function makeTailer() {
+  return new TranscriptTailer({ agentId: "claude", cwd, sink, claudeProjectsDir: claudeDir });
+}
+async function main() {
+  let tailer = makeTailer();
+  tailer.start();
+  await sleep(200);
+  fs2.appendFileSync(sessionFile, line({
+    type: "assistant",
+    cwd,
+    timestamp: now(),
+    message: { role: "assistant", content: [{ type: "text", text: "Reply ONE \u2014 while first enabled." }] }
+  }));
+  await sleep(1500);
+  tailer.stop();
+  era = "between";
+  await sleep(800);
+  era = "enable#2";
+  tailer = makeTailer();
+  tailer.start();
+  await sleep(200);
+  fs2.appendFileSync(sessionFile, line({
+    type: "assistant",
+    cwd,
+    timestamp: now(),
+    message: { role: "assistant", content: [{ type: "text", text: "Reply TWO \u2014 after off then on." }] }
+  }));
+  await sleep(1500);
+  tailer.stop();
+  console.log("\nEmitted entries:");
+  for (const e of emitted) console.log(`  [${e.era}] ${e.type}: ${JSON.stringify(e.content)}`);
+  const two = emitted.filter((e) => e.content.includes("Reply TWO"));
+  console.log("\n--- VERDICT ---");
+  console.log(`Reply ONE emitted while enabled#1: ${emitted.some((e) => e.era === "enable#1" && e.content.includes("Reply ONE"))}`);
+  console.log(`Reply TWO emitted after off\u2192on:    ${two.length > 0}  (count=${two.length}, eras=${JSON.stringify(two.map((e) => e.era))})`);
+  if (two.length === 0) {
+    console.log(">> BUG REPRODUCED: new reply after toggle is NEVER forwarded by the tailer.");
+  } else {
+    console.log(">> Tailer re-emits fine \u2014 bug is NOT in the main-process layer.");
+  }
+  fs2.rmSync(tmp, { recursive: true, force: true });
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {