@phenx-inc/ctlsurf 0.3.8 → 0.3.10

package/out/main/index.js

@@ -9902,13 +9902,13 @@ function requireWebsocketServer() {
   return websocketServer;
 }
 requireWebsocketServer();
-const WS = typeof WebSocket !== "undefined" ? WebSocket : WebSocket$1;
-function log$3(...args) {
+function log$2(...args) {
   try {
     console.log(...args);
   } catch {
   }
 }
+const WS = typeof WebSocket !== "undefined" ? WebSocket : WebSocket$1;
 const HEARTBEAT_INTERVAL_MS = 3e4;
 const RECONNECT_DELAY_MS = 5e3;
 const MAX_RECONNECT_DELAY_MS = 6e4;
@@ -9999,7 +9999,7 @@ class WorkerWsClient {
   }
   doConnect() {
     if (!this.apiKey || !this.registration) {
-      log$3("[worker-ws] No API key or registration, skipping connect");
+      log$2("[worker-ws] No API key or registration, skipping connect");
       return;
     }
     this.clearTimers();
@@ -10022,22 +10022,22 @@ class WorkerWsClient {
   doConnectNow() {
     if (!this.apiKey || !this.registration) return;
     if (!this.shouldReconnect) {
-      log$3("[worker-ws] shouldReconnect is false, aborting connect");
+      log$2("[worker-ws] shouldReconnect is false, aborting connect");
       return;
     }
     this.setStatus("connecting");
     const wsBase = this.baseUrl.replace(/^http/, "ws");
     const url = `${wsBase}/api/ws/worker?token=${encodeURIComponent(this.apiKey)}`;
-    log$3(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
+    log$2(`[worker-ws] Connecting to ${url.replace(/token=.*/, "token=***")}...`);
     try {
       this.ws = new WS(url);
     } catch (err) {
-      log$3("[worker-ws] Failed to create WebSocket:", err);
+      log$2("[worker-ws] Failed to create WebSocket:", err);
       this.scheduleReconnect();
       return;
     }
     this.ws.onopen = () => {
-      log$3("[worker-ws] Connected, sending register");
+      log$2("[worker-ws] Connected, sending register");
       this.reconnectDelay = RECONNECT_DELAY_MS;
       this.send({
         type: "register",
@@ -10050,11 +10050,11 @@ class WorkerWsClient {
         const data = JSON.parse(String(event.data));
         this.handleMessage(data);
       } catch (err) {
-        log$3("[worker-ws] Failed to parse message:", err);
+        log$2("[worker-ws] Failed to parse message:", err);
       }
     };
     this.ws.onclose = (event) => {
-      log$3(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
+      log$2(`[worker-ws] Disconnected: ${event.code} ${event.reason}`);
       this.ws = null;
       this.clearHeartbeat();
       this.setStatus("disconnected");
@@ -10063,7 +10063,7 @@ class WorkerWsClient {
       }
     };
     this.ws.onerror = () => {
-      log$3("[worker-ws] WebSocket error");
+      log$2("[worker-ws] WebSocket error");
     };
   }
   handleMessage(data) {
@@ -10072,7 +10072,7 @@ class WorkerWsClient {
       case "registered": {
         this.workerId = data.worker_id;
         const workerStatus = data.status;
-        console.log(`[worker-ws] Registered as ${this.workerId}, status: ${workerStatus}`);
+        log$2(`[worker-ws] Registered as ${this.workerId}, status: ${workerStatus}`);
         if (workerStatus === "pending_approval") {
           this.setStatus("pending_approval");
         } else {
@@ -10091,14 +10091,14 @@ class WorkerWsClient {
         break;
       }
       case "approved": {
-        log$3("[worker-ws] Worker approved!");
+        log$2("[worker-ws] Worker approved!");
         this.setStatus("connected");
         break;
       }
       case "message": {
         const msg = data.message;
         if (msg) {
-          console.log(`[worker-ws] Received message: ${msg.id}`);
+          log$2(`[worker-ws] Received message: ${msg.id}`);
           this.events.onMessage(msg);
         }
         break;
@@ -10113,7 +10113,7 @@ class WorkerWsClient {
       case "heartbeat_ack":
         break;
       default:
-        console.log(`[worker-ws] Unknown message type: ${msgType}`);
+        log$2(`[worker-ws] Unknown message type: ${msgType}`);
     }
   }
   send(data) {
@@ -10135,7 +10135,7 @@ class WorkerWsClient {
   }
   scheduleReconnect() {
     if (!this.shouldReconnect) return;
-    console.log(`[worker-ws] Reconnecting in ${this.reconnectDelay / 1e3}s...`);
+    log$2(`[worker-ws] Reconnecting in ${this.reconnectDelay / 1e3}s...`);
     this.reconnectTimer = setTimeout(() => {
       this.doConnect();
     }, this.reconnectDelay);
@@ -10178,7 +10178,7 @@ function isSameLocalDay(a, b2) {
   const db = new Date(b2);
   return da.getFullYear() === db.getFullYear() && da.getMonth() === db.getMonth() && da.getDate() === db.getDate();
 }
-function log$2(...args) {
+function log$1(...args) {
   try {
     console.log("[time-tracker]", ...args);
   } catch {
@@ -10234,7 +10234,7 @@ class TimeTracker {
       }
     }, FIRST_CHECKPOINT_DELAY_MS);
     const pending = !state.blockId || !state.rowId;
-    log$2(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore — will retry on each checkpoint)" : ""}`);
+    log$1(`Started tracking tab=${tabId} agent="${agentName}" cwd=${cwd}${pending ? " (pending datastore — 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).
@@ -10258,15 +10258,15 @@ class TimeTracker {
       });
       const rowId = row?.id;
       if (!rowId) {
-        log$2(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
+        log$1(`addRow returned no id for tab=${tabId}; will retry on next checkpoint`);
         return false;
       }
       s.blockId = blockId;
       s.rowId = rowId;
-      log$2(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
+      log$1(`Resolved datastore for tab=${tabId} (cwd=${s.cwd})`);
       return true;
     } catch (err) {
-      log$2(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
+      log$1(`tryResolve failed for tab=${tabId}: ${err?.message || err}`);
       return false;
     }
   }
@@ -10294,12 +10294,12 @@ class TimeTracker {
     if (!s || s.ended) return;
     this.rollingOver.add(tabId);
     const { cwd, agentName, idleTimeoutMin } = s;
-    log$2(`Day rolled over for tab=${tabId}; ending session and starting fresh`);
+    log$1(`Day rolled over for tab=${tabId}; ending session and starting fresh`);
     try {
       await this.endSession(tabId);
       await this.startSession(tabId, cwd, agentName, idleTimeoutMin);
     } catch (err) {
-      log$2(`rollover failed: ${err?.message || err}`);
+      log$1(`rollover failed: ${err?.message || err}`);
     } finally {
       this.rollingOver.delete(tabId);
     }
@@ -10316,10 +10316,10 @@ class TimeTracker {
       if (s.blockId && s.rowId) {
         await this.writeRow(s, Date.now());
       } else {
-        log$2(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
+        log$1(`endSession for tab=${tabId}: never resolved datastore; ${Math.round(s.activeMs / 6e4)}min not recorded`);
       }
     } catch (err) {
-      log$2(`endSession write failed: ${err?.message || err}`);
+      log$1(`endSession write failed: ${err?.message || err}`);
     }
     s.ended = true;
     this.sessions.delete(tabId);
@@ -10337,12 +10337,12 @@ class TimeTracker {
     try {
       await this.writeRow(s, Date.now());
     } catch (err) {
-      log$2(`checkpoint failed: ${err?.message || err}; retrying in 2s`);
+      log$1(`checkpoint failed: ${err?.message || err}; retrying in 2s`);
       setTimeout(() => {
         const live = this.sessions.get(tabId);
         if (!live || live.ended || !live.blockId || !live.rowId) return;
         this.writeRow(live, Date.now()).catch((err2) => {
-          log$2(`checkpoint retry failed: ${err2?.message || err2}`);
+          log$1(`checkpoint retry failed: ${err2?.message || err2}`);
         });
       }, 2e3);
     }
@@ -10381,7 +10381,7 @@ class TimeTracker {
       props: { columns, system_key: SYSTEM_KEY }
     });
     if (created?.id) {
-      log$2(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`);
+      log$1(`Created "${DATASTORE_TITLE}" datastore on Agent Datastore page for ${cwd}`);
       this.blockCache.set(cwd, created.id);
       return created.id;
     }
@@ -10408,7 +10408,7 @@ class TimeTracker {
           titleFallbackProps = props;
         }
       } catch (err) {
-        log$2(`getBlock(${s.id}) failed during lookup: ${err?.message || err}`);
+        log$1(`getBlock(${s.id}) failed during lookup: ${err?.message || err}`);
       }
     }
     if (titleFallbackId) {
@@ -10416,9 +10416,9 @@ class TimeTracker {
         await this.api.updateBlock(titleFallbackId, {
           props: { ...titleFallbackProps || {}, system_key: SYSTEM_KEY }
         });
-        log$2(`Backfilled system_key on legacy Time Tracking block ${titleFallbackId}`);
+        log$1(`Backfilled system_key on legacy Time Tracking block ${titleFallbackId}`);
       } catch (err) {
-        log$2(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`);
+        log$1(`backfill system_key failed on ${titleFallbackId}: ${err?.message || err}`);
       }
       return titleFallbackId;
     }
@@ -10441,18 +10441,12 @@ class TimeTracker {
       });
       const merged = [...existingCols, ...appended];
       await this.api.updateDatastoreSchema(blockId, merged);
-      log$2(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
+      log$1(`Added ${missing.length} missing column(s) to existing Time Tracking datastore: ${missing.map((c) => c.name).join(", ")}`);
     } catch (err) {
-      log$2(`ensureColumns failed: ${err?.message || err}`);
+      log$1(`ensureColumns failed: ${err?.message || err}`);
     }
   }
 }
-function log$1(...args) {
-  try {
-    console.log(...args);
-  } catch {
-  }
-}
 const DEFAULT_IDLE_TIMEOUT_MIN = 15;
 const DEFAULT_PROFILES = {
   production: {
@@ -10465,6 +10459,7 @@ const DEFAULT_PROFILES = {
   }
 };
 const TERM_STREAM_INTERVAL_MS = 50;
+const NO_PROJECT_POLL_MS = 5e3;
 class Orchestrator {
   settingsDir;
   events;
@@ -10483,16 +10478,18 @@ class Orchestrator {
     profiles: { ...DEFAULT_PROFILES },
     logChat: false
   };
+  noProjectPollTimer = null;
+  noProjectPollCwd = null;
   constructor(settingsDir, events) {
     this.settingsDir = settingsDir;
     this.events = events;
     this.workerWs = new WorkerWsClient({
       onStatusChange: (status) => {
-        log$1(`[worker-ws] Status: ${status}`);
+        log$2(`[worker-ws] Status: ${status}`);
         events.onWorkerStatus(status);
       },
       onMessage: (message) => {
-        log$1(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
+        log$2(`[worker-ws] Incoming message: ${message.id} (${message.type})`);
         events.onWorkerMessage(message);
         this.workerWs.sendAck(message.id);
         if (message.type === "prompt" || message.type === "task_dispatch") {
@@ -10504,10 +10501,15 @@ class Orchestrator {
         }
       },
       onRegistered: (data) => {
-        log$1(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
+        log$2(`[worker-ws] Registered: worker_id=${data.worker_id}, folder_id=${data.folder_id}, status=${data.status}`);
         events.onWorkerRegistered(data);
         if (!data.folder_id) {
           events.onWorkerStatus("no_project");
+          if (this.currentCwd && data.status !== "pending_approval") {
+            this.startNoProjectPolling(this.currentCwd);
+          }
+        } else {
+          this.stopNoProjectPolling();
         }
       },
       onTerminalInput: (data) => {
@@ -10557,7 +10559,7 @@ class Orchestrator {
     const baseUrl = profile.baseUrl || process.env.CTLSURF_BASE_URL || "https://app.ctlsurf.com";
     this.ctlsurfApi.setBaseUrl(baseUrl);
     this.workerWs.setBaseUrl(baseUrl);
-    log$1(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
+    log$2(`[settings] Profile applied: ${profile.name} (${baseUrl})`);
   }
   loadSettings() {
     try {
@@ -10582,7 +10584,7 @@ class Orchestrator {
             logChat: !!raw.logChat
           };
           this.saveSettings();
-          log$1("[settings] Migrated legacy settings to profiles");
+          log$2("[settings] Migrated legacy settings to profiles");
         } else {
           this.settings = raw;
           if (!this.settings.profiles.production) {
@@ -10609,7 +10611,7 @@ class Orchestrator {
       fs.mkdirSync(this.settingsDir, { recursive: true });
       fs.writeFileSync(settingsPath, JSON.stringify(this.settings, null, 2));
     } catch (err) {
-      log$1("[settings] Failed to save:", err.message);
+      log$2("[settings] Failed to save:", err.message);
     }
   }
   overrideApiKey(key) {
@@ -10747,6 +10749,7 @@ class Orchestrator {
     if (isCodingAgent(agent)) {
       this.connectWorkerWs(agent, cwd);
     } else {
+      this.stopNoProjectPolling();
       this.workerWs.disconnect();
       this.checkProjectStatus(cwd);
     }
@@ -10818,15 +10821,50 @@ class Orchestrator {
     const profile = this.getActiveProfile();
     const apiKey = profile.apiKey || process.env.CTLSURF_API_KEY;
     if (!apiKey) {
-      log$1("[worker-ws] No API key, skipping WS connect");
+      log$2("[worker-ws] No API key, skipping WS connect");
       return;
     }
+    this.stopNoProjectPolling();
     this.workerWs.connect({
       machine: os.hostname(),
       cwd,
       agent: agent.name
     });
   }
+  startNoProjectPolling(cwd) {
+    if (this.noProjectPollTimer && this.noProjectPollCwd === cwd) return;
+    this.stopNoProjectPolling();
+    this.noProjectPollCwd = cwd;
+    log$2(`[worker-ws] Polling for project folder at ${cwd}`);
+    this.noProjectPollTimer = setInterval(() => {
+      void this.checkForProjectFolder(cwd);
+    }, NO_PROJECT_POLL_MS);
+  }
+  stopNoProjectPolling() {
+    if (this.noProjectPollTimer) {
+      clearInterval(this.noProjectPollTimer);
+      this.noProjectPollTimer = null;
+      this.noProjectPollCwd = null;
+    }
+  }
+  async checkForProjectFolder(cwd) {
+    if (this.currentCwd !== cwd || !this.currentAgent) {
+      this.stopNoProjectPolling();
+      return;
+    }
+    if (!this.ctlsurfApi.getApiKey()) return;
+    try {
+      const folder = await this.ctlsurfApi.findFolderByPath(cwd);
+      if (folder?.id && this.currentCwd === cwd && this.currentAgent) {
+        log$2(`[worker-ws] Project folder appeared (${folder.id}); reconnecting`);
+        const agent = this.currentAgent;
+        this.stopNoProjectPolling();
+        this.workerWs.disconnect();
+        this.connectWorkerWs(agent, cwd);
+      }
+    } catch {
+    }
+  }
   async checkProjectStatus(cwd) {
     if (!this.ctlsurfApi.getApiKey()) {
       this.events.onWorkerStatus("no_project");
@@ -10857,6 +10895,7 @@ class Orchestrator {
   }
   // ─── Shutdown ───────────────────────────────────
   async shutdown() {
+    this.stopNoProjectPolling();
     this.bridge.endSession();
     await this.timeTracker.endAll();
     for (const [, tab] of this.tabs) {
@@ -10867,6 +10906,8 @@ class Orchestrator {
     this.workerWs.disconnect();
   }
 }
+electron.app.setName("ctlsurf");
+process.title = "ctlsurf";
 process.stdout?.on?.("error", () => {
 });
 process.stderr?.on?.("error", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "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": {

package/scripts/rebrand-electron.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+
+/**
+ * Rebrand the Electron binary inside node_modules so the app shows up as
+ * "ctlsurf" (with our icon) in macOS Activity Monitor / Windows Task Manager
+ * instead of "Electron".
+ *
+ * Idempotent: writes a sentinel file and skips if already done.
+ * Re-runs automatically after `npm update` (which wipes node_modules/electron).
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execFileSync } = require('child_process')
+
+const ROOT = path.resolve(__dirname, '..')
+const PRODUCT_NAME = 'ctlsurf'
+const ELECTRON_DIR = path.join(ROOT, 'node_modules', 'electron')
+const SENTINEL = path.join(ELECTRON_DIR, '.ctlsurf-rebranded')
+
+function log(msg) {
+  if (!process.env.CTLSURF_QUIET) console.log(`[ctlsurf:rebrand] ${msg}`)
+}
+
+function rebrand() {
+  if (!fs.existsSync(ELECTRON_DIR)) return false
+
+  if (fs.existsSync(SENTINEL)) return true
+
+  let pathTxtPath = path.join(ELECTRON_DIR, 'path.txt')
+  if (!fs.existsSync(pathTxtPath)) return false
+
+  const relBin = fs.readFileSync(pathTxtPath, 'utf-8').trim()
+  const electronBinary = path.join(ELECTRON_DIR, relBin)
+
+  try {
+    if (process.platform === 'darwin') {
+      rebrandDarwin(electronBinary, pathTxtPath)
+    } else if (process.platform === 'linux') {
+      rebrandLinux(electronBinary, pathTxtPath)
+    } else if (process.platform === 'win32') {
+      rebrandWin32(electronBinary, pathTxtPath)
+    } else {
+      return false
+    }
+  } catch (err) {
+    log(`failed: ${err.message}`)
+    return false
+  }
+
+  fs.writeFileSync(SENTINEL, new Date().toISOString())
+  log('done')
+  return true
+}
+
+// ─── macOS ──────────────────────────────────────────
+
+function rebrandDarwin(electronBinary, pathTxtPath) {
+  // electronBinary = .../node_modules/electron/dist/Electron.app/Contents/MacOS/Electron
+  const macosDir = path.dirname(electronBinary)
+  const contentsDir = path.dirname(macosDir)
+  const appDir = path.dirname(contentsDir)
+  const distDir = path.dirname(appDir)
+  const newAppDir = path.join(distDir, `${PRODUCT_NAME}.app`)
+
+  // 1) Rename main executable inside MacOS/
+  const newBinaryPath = path.join(macosDir, PRODUCT_NAME)
+  if (fs.existsSync(electronBinary) && electronBinary !== newBinaryPath) {
+    fs.renameSync(electronBinary, newBinaryPath)
+  }
+
+  // 2) Replace icon
+  const ourIcon = path.join(ROOT, 'resources', 'icon.icns')
+  const electronIcon = path.join(contentsDir, 'Resources', 'electron.icns')
+  if (fs.existsSync(ourIcon) && fs.existsSync(electronIcon)) {
+    fs.copyFileSync(ourIcon, electronIcon)
+  }
+
+  // 3) Patch main Info.plist
+  patchInfoPlist(path.join(contentsDir, 'Info.plist'), {
+    CFBundleName: PRODUCT_NAME,
+    CFBundleDisplayName: PRODUCT_NAME,
+    CFBundleExecutable: PRODUCT_NAME,
+  })
+
+  // 4) Rebrand helper apps so renderer/GPU subprocesses also show as "ctlsurf Helper"
+  const frameworksDir = path.join(contentsDir, 'Frameworks')
+  if (fs.existsSync(frameworksDir)) {
+    for (const entry of fs.readdirSync(frameworksDir)) {
+      if (entry.startsWith('Electron Helper') && entry.endsWith('.app')) {
+        rebrandHelper(path.join(frameworksDir, entry))
+      }
+    }
+  }
+
+  // 5) Rename .app bundle directory
+  let finalAppDir = appDir
+  if (appDir !== newAppDir && !fs.existsSync(newAppDir)) {
+    fs.renameSync(appDir, newAppDir)
+    finalAppDir = newAppDir
+  }
+
+  // 6) Update path.txt to point at new bundle/binary
+  const newRel = path.join('dist', `${PRODUCT_NAME}.app`, 'Contents', 'MacOS', PRODUCT_NAME)
+  fs.writeFileSync(pathTxtPath, newRel)
+
+  // 7) Re-sign ad-hoc — original signature is invalidated by our edits, and
+  //    Gatekeeper / hardened-runtime macOS configs will refuse to load the
+  //    helper frameworks otherwise.
+  try {
+    execFileSync('codesign', ['--remove-signature', finalAppDir], { stdio: 'ignore' })
+  } catch { /* ignore */ }
+  try {
+    execFileSync('codesign', ['--force', '--deep', '--sign', '-', finalAppDir], { stdio: 'ignore' })
+  } catch { /* ignore — best-effort */ }
+}
+
+function rebrandHelper(helperAppDir) {
+  // e.g. helperAppDir = ".../Electron Helper (Renderer).app"
+  const oldName = path.basename(helperAppDir, '.app')         // "Electron Helper (Renderer)"
+  const suffix = oldName.replace(/^Electron Helper/, '').trim() // "(Renderer)" or ""
+  const newName = suffix ? `${PRODUCT_NAME} Helper ${suffix}` : `${PRODUCT_NAME} Helper`
+
+  const macosDir = path.join(helperAppDir, 'Contents', 'MacOS')
+  const oldBinary = path.join(macosDir, oldName)
+  const newBinary = path.join(macosDir, newName)
+  if (fs.existsSync(oldBinary) && oldBinary !== newBinary) {
+    fs.renameSync(oldBinary, newBinary)
+  }
+
+  patchInfoPlist(path.join(helperAppDir, 'Contents', 'Info.plist'), {
+    CFBundleName: newName,
+    CFBundleDisplayName: newName,
+    CFBundleExecutable: newName,
+  })
+
+  const newAppDir = path.join(path.dirname(helperAppDir), `${newName}.app`)
+  if (helperAppDir !== newAppDir && !fs.existsSync(newAppDir)) {
+    fs.renameSync(helperAppDir, newAppDir)
+  }
+}
+
+function patchInfoPlist(plistPath, kv) {
+  if (!fs.existsSync(plistPath)) return
+  for (const [key, val] of Object.entries(kv)) {
+    try {
+      execFileSync('plutil', ['-replace', key, '-string', val, plistPath], { stdio: 'ignore' })
+    } catch {
+      try {
+        execFileSync('plutil', ['-insert', key, '-string', val, plistPath], { stdio: 'ignore' })
+      } catch { /* ignore */ }
+    }
+  }
+}
+
+// ─── Linux ──────────────────────────────────────────
+
+function rebrandLinux(electronBinary, pathTxtPath) {
+  // dist/electron → dist/ctlsurf (process title comes from argv[0]/comm on linux)
+  const dir = path.dirname(electronBinary)
+  const newBinary = path.join(dir, PRODUCT_NAME)
+  if (fs.existsSync(electronBinary) && !fs.existsSync(newBinary)) {
+    fs.renameSync(electronBinary, newBinary)
+  }
+  fs.writeFileSync(pathTxtPath, path.join('dist', PRODUCT_NAME))
+}
+
+// ─── Windows ────────────────────────────────────────
+
+function rebrandWin32(electronBinary, pathTxtPath) {
+  // dist/electron.exe → dist/ctlsurf.exe
+  // (Embedding our icon into the exe resource table requires rcedit; out of
+  // scope for npm-install distribution. Renaming gives correct Task Manager
+  // process name; icon in tray/window comes from BrowserWindow.icon.)
+  const dir = path.dirname(electronBinary)
+  const newBinary = path.join(dir, `${PRODUCT_NAME}.exe`)
+  if (fs.existsSync(electronBinary) && !fs.existsSync(newBinary)) {
+    fs.renameSync(electronBinary, newBinary)
+  }
+  fs.writeFileSync(pathTxtPath, path.join('dist', `${PRODUCT_NAME}.exe`))
+}
+
+// ─── Entry ──────────────────────────────────────────
+
+if (require.main === module) {
+  const ok = rebrand()
+  if (!ok && !fs.existsSync(ELECTRON_DIR)) {
+    // Electron not installed yet — silent no-op; launcher will rerun us
+    // after just-in-time install.
+    process.exit(0)
+  }
+  process.exit(0)
+}
+
+module.exports = { rebrand }

package/src/main/headless.ts

@@ -21,6 +21,12 @@ process.on('uncaughtException', (err) => {
   try { console.error('[uncaught]', err) } catch { /* ignore */ }
 })
 
+import { setSilent } from './logger'
+
+// PTY owns the screen in TUI mode — silence background logs so they don't
+// corrupt the agent's display.
+setSilent(true)
+
 import { Orchestrator } from './orchestrator'
 import { getSettingsDir } from './settingsDir'
 import { getBuiltinAgents, isCodingAgent, type AgentConfig } from './agents'

package/src/main/index.ts

@@ -4,6 +4,12 @@ import fs from 'fs'
 
 import { fetchLatestNpmVersion, compareSemver } from './updateCheck'
 
+// Set app name early — drives the macOS menu bar title, dock label, and the
+// CFBundleName fallback. The Activity Monitor process name is set by the
+// rebranded Electron.app bundle (see scripts/rebrand-electron.js).
+app.setName('ctlsurf')
+process.title = 'ctlsurf'
+
 // Prevent EPIPE crashes when stdout pipe is closed
 process.stdout?.on?.('error', () => {})
 process.stderr?.on?.('error', () => {})

package/src/main/logger.ts

@@ -0,0 +1,10 @@
+let silent = false
+
+export function setSilent(value: boolean): void {
+  silent = value
+}
+
+export function log(...args: unknown[]): void {
+  if (silent) return
+  try { console.log(...args) } catch { /* EPIPE safe */ }
+}