@phenx-inc/ctlsurf 0.3.6 → 0.3.8

package/out/headless/index.mjs

@@ -5466,6 +5466,88 @@ var require_electron = __commonJS({
   }
 });
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@phenx-inc/ctlsurf",
+      version: "0.3.8",
+      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: {
+        ctlsurf: "./bin/ctlsurf-worker.js",
+        "ctlsurf-worker": "./bin/ctlsurf-worker.js"
+      },
+      files: [
+        "bin/",
+        "out/",
+        "resources/",
+        "scripts/",
+        "src/",
+        "package.json",
+        "electron-vite.config.ts",
+        "tsconfig*.json"
+      ],
+      scripts: {
+        dev: "electron-vite dev",
+        "dev:terminal": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --external:ws --sourcemap && node out/headless/index.mjs",
+        build: "electron-vite build && npm run build:headless",
+        "build:headless": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --external:ws --sourcemap",
+        prepublishOnly: "npm run build",
+        preview: "electron-vite preview",
+        package: "electron-builder",
+        postinstall: "node-gyp rebuild --directory=node_modules/node-pty 2>/dev/null || true"
+      },
+      keywords: [
+        "ctlsurf",
+        "terminal",
+        "tui",
+        "coding-agent",
+        "claude-code",
+        "codex",
+        "electron",
+        "node-pty",
+        "xterm"
+      ],
+      license: "MIT",
+      engines: {
+        node: ">=18"
+      },
+      dependencies: {
+        "@monaco-editor/react": "^4.7.0",
+        "@xterm/addon-fit": "^0.10.0",
+        "@xterm/addon-serialize": "^0.14.0",
+        "@xterm/addon-web-links": "^0.11.0",
+        "@xterm/headless": "^6.0.0",
+        "@xterm/xterm": "^5.5.0",
+        "electron-store": "^10.0.0",
+        esbuild: "^0.27.4",
+        "monaco-editor": "^0.55.1",
+        "node-pty": "^1.0.0",
+        ws: "^8.20.0"
+      },
+      devDependencies: {
+        "@electron/rebuild": "^4.0.3",
+        "@types/node": "^22.15.0",
+        "@types/react": "^19.1.0",
+        "@types/react-dom": "^19.1.0",
+        "@types/ws": "^8.18.1",
+        "@vitejs/plugin-react": "^4.5.2",
+        electron: "^35.0.0",
+        "electron-builder": "^25.1.8",
+        "electron-vite": "^3.1.0",
+        react: "^19.1.0",
+        "react-dom": "^19.1.0",
+        typescript: "^5.8.3"
+      },
+      optionalDependencies: {
+        bufferutil: "^4.1.0",
+        "utf-8-validate": "^6.0.6"
+      }
+    };
+  }
+});
+
 // src/main/orchestrator.ts
 import path from "path";
 import fs from "fs";
@@ -5682,6 +5764,7 @@ var import_addon_serialize = __toESM(require_addon_serialize());
 var ConversationBridge = class {
   wsClient = null;
   sessionActive = false;
+  loggingEnabled = false;
   inputBuffer = "";
   outputBuffer = "";
   outputFlushTimer = null;
@@ -5691,7 +5774,11 @@ var ConversationBridge = class {
   setWsClient(ws) {
     this.wsClient = ws;
   }
+  setLoggingEnabled(enabled) {
+    this.loggingEnabled = enabled;
+  }
   startSession() {
+    if (!this.loggingEnabled) return;
     this.clearOutputTimers();
     this.outputBuffer = "";
     this.inputBuffer = "";
@@ -5700,13 +5787,13 @@ var ConversationBridge = class {
     console.log("[bridge] Session started");
   }
   feedOutput(data) {
-    if (!this.sessionActive) return;
+    if (!this.sessionActive || !this.loggingEnabled) return;
     this.outputBuffer += data;
     this.terminalCapture.write(data);
     this.scheduleOutputFlush();
   }
   feedInput(data) {
-    if (!this.sessionActive) return;
+    if (!this.sessionActive || !this.loggingEnabled) return;
     this.inputBuffer += data;
     if (data.includes("\r") || data.includes("\n")) {
       const cleaned = cleanInput(this.inputBuffer);
@@ -5728,7 +5815,7 @@ var ConversationBridge = class {
     this.sendEntry("terminal_output", cleaned);
   }
   sendEntry(type, content) {
-    if (!this.wsClient) return;
+    if (!this.wsClient || !this.loggingEnabled) return;
     this.wsClient.sendChatLog({
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type,
@@ -6271,55 +6358,68 @@ var TimeTracker = class {
     if (this.sessions.has(tabId)) {
       await this.endSession(tabId);
     }
-    try {
-      const blockId = await this.ensureDatastore(cwd);
-      if (!blockId) {
-        log2(`No "${AGENT_DATASTORE_PAGE_TITLE}" page found for ${cwd} \u2014 tracking disabled for this session`);
-        return;
+    const startedAt = Date.now();
+    const state = {
+      blockId: null,
+      rowId: null,
+      sessionUuid: randomUUID(),
+      cwd,
+      agentName,
+      idleTimeoutMin,
+      startedAt,
+      lastActivity: startedAt,
+      activeMs: 0,
+      idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1e3,
+      firstCheckpointTimer: null,
+      checkpointTimer: null,
+      ended: false
+    };
+    this.sessions.set(tabId, state);
+    await this.tryResolve(tabId);
+    state.firstCheckpointTimer = setTimeout(() => {
+      void this.checkpoint(tabId);
+      const live = this.sessions.get(tabId);
+      if (live && !live.ended) {
+        live.checkpointTimer = setInterval(() => {
+          void this.checkpoint(tabId);
+        }, CHECKPOINT_INTERVAL_MS);
       }
-      const startedAt = Date.now();
-      const sessionUuid = randomUUID();
+    }, FIRST_CHECKPOINT_DELAY_MS);
+    const pending = !state.blockId || !state.rowId;
+    log2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore \u2014 will retry on each checkpoint)" : ""}`);
+  }
+  /** Attempts to locate (or create) the datastore + add the session row.
+   * Returns true once the session is resolved (blockId + rowId set).
+   * Safe to call repeatedly: re-running while pending will keep retrying;
+   * once resolved it's a no-op. */
+  async tryResolve(tabId) {
+    const s = this.sessions.get(tabId);
+    if (!s) return false;
+    if (s.blockId && s.rowId) return true;
+    try {
+      const blockId = await this.ensureDatastore(s.cwd);
+      if (!blockId) return false;
       const row = await this.api.addRow(blockId, {
-        Started: formatStarted(startedAt),
-        "Active Time": 0,
-        "Last Updated": new Date(startedAt).toISOString(),
-        Agent: agentName,
+        Started: formatStarted(s.startedAt),
+        "Active Time": Math.round(s.activeMs / 6e4),
+        "Last Updated": (/* @__PURE__ */ new Date()).toISOString(),
+        Agent: s.agentName,
         Worker: os2.hostname(),
-        Session: sessionUuid,
+        Session: s.sessionUuid,
         Notes: ""
       });
       const rowId = row?.id;
       if (!rowId) {
-        log2("addRow returned no id; aborting tracking", row);
-        return;
+        log2(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
+        return false;
       }
-      const state = {
-        blockId,
-        rowId,
-        cwd,
-        agentName,
-        idleTimeoutMin,
-        startedAt,
-        lastActivity: startedAt,
-        activeMs: 0,
-        idleTimeoutMs: Math.max(1, idleTimeoutMin) * 60 * 1e3,
-        firstCheckpointTimer: null,
-        checkpointTimer: null,
-        ended: false
-      };
-      state.firstCheckpointTimer = setTimeout(() => {
-        void this.checkpoint(tabId);
-        const live = this.sessions.get(tabId);
-        if (live && !live.ended) {
-          live.checkpointTimer = setInterval(() => {
-            void this.checkpoint(tabId);
-          }, CHECKPOINT_INTERVAL_MS);
-        }
-      }, FIRST_CHECKPOINT_DELAY_MS);
-      this.sessions.set(tabId, state);
-      log2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}`);
+      s.blockId = blockId;
+      s.rowId = rowId;
+      log2(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
+      return true;
     } catch (err) {
-      log2(`startSession failed: ${err?.message || err}`);
+      log2(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
+      return false;
     }
   }
   isTracking(tabId) {
@@ -6359,14 +6459,21 @@ var TimeTracker = class {
   async endSession(tabId) {
     const s = this.sessions.get(tabId);
     if (!s || s.ended) return;
-    s.ended = true;
     if (s.firstCheckpointTimer) clearTimeout(s.firstCheckpointTimer);
     if (s.checkpointTimer) clearInterval(s.checkpointTimer);
     try {
-      await this.writeRow(s, Date.now());
+      if (!s.blockId || !s.rowId) {
+        await this.tryResolve(tabId);
+      }
+      if (s.blockId && s.rowId) {
+        await this.writeRow(s, Date.now());
+      } else {
+        log2(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
+      }
     } catch (err) {
       log2(`endSession write failed: ${err?.message || err}`);
     }
+    s.ended = true;
     this.sessions.delete(tabId);
   }
   async endAll() {
@@ -6376,13 +6483,16 @@ var TimeTracker = class {
   async checkpoint(tabId) {
     const s = this.sessions.get(tabId);
     if (!s || s.ended) return;
+    if (!s.blockId || !s.rowId) {
+      if (!await this.tryResolve(tabId)) return;
+    }
     try {
       await this.writeRow(s, Date.now());
     } catch (err) {
       log2(`checkpoint failed: ${err?.message || err}; retrying in 2s`);
       setTimeout(() => {
         const live = this.sessions.get(tabId);
-        if (!live || live.ended) return;
+        if (!live || live.ended || !live.blockId || !live.rowId) return;
         this.writeRow(live, Date.now()).catch((err2) => {
           log2(`checkpoint retry failed: ${err2?.message || err2}`);
         });
@@ -6390,6 +6500,7 @@ var TimeTracker = class {
     }
   }
   async writeRow(s, _endTimeMs) {
+    if (!s.blockId || !s.rowId) return;
     const activeMin = Math.round(s.activeMs / 6e4);
     await this.api.updateRow(s.blockId, s.rowId, {
       "Active Time": activeMin,
@@ -6523,7 +6634,8 @@ var Orchestrator = class {
   currentCwd = null;
   settings = {
     activeProfile: "production",
-    profiles: { ...DEFAULT_PROFILES }
+    profiles: { ...DEFAULT_PROFILES },
+    logChat: false
   };
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
@@ -6558,6 +6670,21 @@ var Orchestrator = class {
       }
     });
     this.bridge.setWsClient(this.workerWs);
+    this.bridge.setLoggingEnabled(!!this.settings.logChat);
+  }
+  // ─── Chat logging ───────────────────────────────
+  get logChatEnabled() {
+    return !!this.settings.logChat;
+  }
+  setLogChat(enabled) {
+    this.settings.logChat = enabled;
+    this.saveSettings();
+    this.bridge.setLoggingEnabled(enabled);
+    if (!enabled) {
+      this.bridge.endSession();
+    } else if (this.activeTabId) {
+      this.bridge.startSession();
+    }
   }
   // ─── Settings ───────────────────────────────────
   getActiveProfile() {
@@ -6605,7 +6732,8 @@ var Orchestrator = class {
                 baseUrl: raw.ctlsurfBaseUrl || "https://app.ctlsurf.com",
                 dataspacePageId: raw.ctlsurfDataspacePageId || ""
               }
-            }
+            },
+            logChat: !!raw.logChat
           };
           this.saveSettings();
           log3("[settings] Migrated legacy settings to profiles");
@@ -6614,15 +6742,20 @@ var Orchestrator = class {
           if (!this.settings.profiles.production) {
             this.settings.profiles.production = { ...DEFAULT_PROFILES.production };
           }
+          if (this.settings.logChat === void 0) {
+            this.settings.logChat = false;
+          }
         }
       }
     } catch {
       this.settings = {
         activeProfile: "production",
-        profiles: { ...DEFAULT_PROFILES }
+        profiles: { ...DEFAULT_PROFILES },
+        logChat: false
       };
     }
     this.applyProfile(this.getActiveProfile());
+    this.bridge.setLoggingEnabled(!!this.settings.logChat);
   }
   saveSettings() {
     const settingsPath = path.join(this.settingsDir, "settings.json");
@@ -6752,7 +6885,9 @@ var Orchestrator = class {
       const t = this.tabs.get(tabId);
       if (t?.termStreamTimer) clearTimeout(t.termStreamTimer);
     });
-    this.bridge.startSession();
+    if (this.settings.logChat) {
+      this.bridge.startSession();
+    }
     const profile = this.getActiveProfile();
     const shouldTrack = opts?.trackTime !== void 0 ? opts.trackTime : profile.trackTime !== false;
     if (shouldTrack) {
@@ -7010,8 +7145,9 @@ var Tui = class {
     return new Promise((resolve) => {
       let selected = 0;
       let trackTime = options.initialTrackTime;
+      let logChat = options.initialLogChat;
       const modalWidth = 44;
-      const modalHeight = agents.length + 4 + 2;
+      const modalHeight = agents.length + 4 + 3;
       const startCol = Math.max(1, Math.floor((this.cols - modalWidth) / 2));
       const startRow = Math.max(1, Math.floor((this.rows - modalHeight) / 2));
       this.write(`${CSI}?1049h`);
@@ -7055,9 +7191,16 @@ var Tui = class {
         const trackContentLen = 2 + 3 + 1 + "Track time".length;
         const trackPad = " ".repeat(Math.max(0, modalWidth - 2 - trackContentLen));
         this.write(`${CSI}${trackRow};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${trackContent}${trackPad}${FG_DIM}\u2502${RESET}`);
-        const botRow = trackRow + 1;
+        const logRow = trackRow + 1;
+        const logCheckbox = logChat ? `${FG_GREEN}[\u2713]${RESET}${BG_MODAL}` : `${FG_DIM}[ ]${RESET}${BG_MODAL}`;
+        const logLabelFg = logChat ? FG_WHITE : FG_DIM;
+        const logContent = `  ${logCheckbox} ${logLabelFg}Log chat${RESET}${BG_MODAL}`;
+        const logContentLen = 2 + 3 + 1 + "Log chat".length;
+        const logPad = " ".repeat(Math.max(0, modalWidth - 2 - logContentLen));
+        this.write(`${CSI}${logRow};${startCol}H${BG_MODAL}${FG_DIM}\u2502${RESET}${BG_MODAL}${logContent}${logPad}${FG_DIM}\u2502${RESET}`);
+        const botRow = logRow + 1;
         this.write(`${CSI}${botRow};${startCol}H${BG_MODAL}${FG_DIM}${botBorder}${RESET}`);
-        const hint = "\u2191\u2193 navigate \xB7 Enter select \xB7 t track \xB7 q quit";
+        const hint = "\u2191\u2193 nav \xB7 Enter \xB7 t track \xB7 l log \xB7 q quit";
         const hintCol = Math.max(1, Math.floor((this.cols - hint.length) / 2));
         this.write(`${CSI}${botRow + 2};${hintCol}H${FG_DIM}${hint}${RESET}`);
       };
@@ -7074,12 +7217,15 @@ var Tui = class {
         } else if (key === "\x1B[B" || key === "j") {
           selected = (selected + 1) % agents.length;
           drawModal();
-        } else if (key === "t" || key === "T" || key === " ") {
+        } else if (key === "t" || key === "T") {
           trackTime = !trackTime;
           drawModal();
+        } else if (key === "l" || key === "L") {
+          logChat = !logChat;
+          drawModal();
         } else if (key === "\r" || key === "\n") {
           cleanup();
-          resolve({ agentIdx: selected, trackTime });
+          resolve({ agentIdx: selected, trackTime, logChat });
         } else if (key === "q" || key === "\x1B" || key === "") {
           cleanup();
           this.write(`${CSI}?25h`);
@@ -7146,6 +7292,50 @@ var Tui = class {
   }
 };
 
+// src/main/updateCheck.ts
+import https from "https";
+var NPM_PACKAGE = "@phenx-inc/ctlsurf";
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    const ai = pa[i] || 0;
+    const bi = pb[i] || 0;
+    if (ai !== bi) return ai - bi;
+  }
+  return 0;
+}
+function fetchLatestNpmVersion(timeoutMs = 8e3) {
+  return new Promise((resolve) => {
+    const url = `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE)}/latest`;
+    const req = https.get(url, { headers: { "Accept": "application/json" } }, (res) => {
+      if (res.statusCode !== 200) {
+        res.resume();
+        resolve(null);
+        return;
+      }
+      let body = "";
+      res.setEncoding("utf8");
+      res.on("data", (chunk) => {
+        body += chunk;
+      });
+      res.on("end", () => {
+        try {
+          const json = JSON.parse(body);
+          resolve(typeof json?.version === "string" ? json.version : null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on("error", () => resolve(null));
+    req.setTimeout(timeoutMs, () => {
+      req.destroy();
+      resolve(null);
+    });
+  });
+}
+
 // src/main/headless.ts
 process.stdout?.on?.("error", () => {
 });
@@ -7158,6 +7348,14 @@ process.on("uncaughtException", (err) => {
   } catch {
   }
 });
+function getCurrentVersion() {
+  try {
+    const pkg = require_package();
+    return typeof pkg?.version === "string" ? pkg.version : "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
 function parseArgs(argv) {
   const args = {
     agent: null,
@@ -7198,9 +7396,27 @@ function parseArgs(argv) {
   }
   return args;
 }
+async function checkVersionAndNotify() {
+  const current = getCurrentVersion();
+  const latest = await fetchLatestNpmVersion(3e3);
+  if (!latest) return;
+  if (compareSemver(latest, current) <= 0) return;
+  const Y = "\x1B[33m";
+  const G = "\x1B[32m";
+  const D = "\x1B[90m";
+  const R = "\x1B[0m";
+  process.stdout.write(
+    `
+${Y}A new version of ctlsurf is available${R} ${D}(${current} \u2192 ${latest})${R}
+  Update: ${G}npm i -g ${NPM_PACKAGE}${R}
+
+`
+  );
+}
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   const settingsDir = getSettingsDir(false);
+  await checkVersionAndNotify();
   const tui = new Tui();
   const agents = getBuiltinAgents();
   const orchestrator = new Orchestrator(settingsDir, {
@@ -7241,9 +7457,13 @@ async function main() {
     };
   } else {
     const initialTrackTime = orchestrator.getActiveProfile().trackTime !== false;
-    const picked = await tui.showAgentPicker(agents, { initialTrackTime });
+    const initialLogChat = orchestrator.logChatEnabled;
+    const picked = await tui.showAgentPicker(agents, { initialTrackTime, initialLogChat });
     agent = agents[picked.agentIdx];
     trackTimeOverride = picked.trackTime;
+    if (picked.logChat !== orchestrator.logChatEnabled) {
+      orchestrator.setLogChat(picked.logChat);
+    }
   }
   tui.update({
     agentName: agent.name,