@phenx-inc/ctlsurf 0.16.1 → 0.17.1

package/scripts/extract-electron.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+/**
+ * Fallback installer for the Electron binary inside node_modules.
+ *
+ * electron <40 unzips its binary in postinstall with extract-zip@2/yauzl@2,
+ * which on Node >= 26 silently stops partway through the archive: the
+ * process exits 0, dist/ is left half-extracted and path.txt is never
+ * written, so require('electron') throws "Electron failed to install
+ * correctly". npm then considers the package installed and won't re-run
+ * the postinstall.
+ *
+ * This fetches the same zip through @electron/get (normally a cache hit —
+ * the broken postinstall already downloaded it), extracts it with the OS's
+ * own unzip tool, and writes path.txt the same way electron/install.js does.
+ *
+ * Run as a child process by bin/ctlsurf-worker.js; exits non-zero on failure.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { execFileSync } = require('child_process')
+
+const ROOT = path.resolve(__dirname, '..')
+const ELECTRON_DIR = path.join(ROOT, 'node_modules', 'electron')
+const SENTINEL = path.join(ELECTRON_DIR, '.ctlsurf-rebranded')
+
+function getPlatformPath() {
+  switch (process.platform) {
+    case 'darwin': return 'Electron.app/Contents/MacOS/Electron'
+    case 'linux': return 'electron'
+    case 'win32': return 'electron.exe'
+    default: throw new Error(`Electron builds are not available on platform: ${process.platform}`)
+  }
+}
+
+function getArch() {
+  // Mirror electron/install.js: x64 node under Rosetta still wants arm64.
+  if (process.platform === 'darwin' && process.arch === 'x64') {
+    try {
+      if (execFileSync('sysctl', ['-in', 'sysctl.proc_translated']).toString().trim() === '1') return 'arm64'
+    } catch { /* ignore */ }
+  }
+  return process.arch
+}
+
+function unzip(zipPath, distDir) {
+  if (process.platform === 'darwin') {
+    // ditto keeps the framework symlinks inside Electron.app intact
+    execFileSync('ditto', ['-x', '-k', zipPath, distDir], { stdio: 'inherit' })
+  } else if (process.platform === 'win32') {
+    // bsdtar ships with Windows 10+ and reads zip archives
+    execFileSync('tar', ['-xf', zipPath, '-C', distDir], { stdio: 'inherit' })
+  } else {
+    execFileSync('unzip', ['-q', '-o', zipPath, '-d', distDir], { stdio: 'inherit' })
+  }
+}
+
+async function extractElectron() {
+  const platformPath = getPlatformPath()
+  const { version } = require(path.join(ELECTRON_DIR, 'package.json'))
+  const { downloadArtifact } = require(require.resolve('@electron/get', { paths: [ELECTRON_DIR] }))
+
+  const zipPath = await downloadArtifact({
+    version,
+    artifactName: 'electron',
+    cacheRoot: process.env.electron_config_cache,
+    checksums: require(path.join(ELECTRON_DIR, 'checksums.json')),
+    platform: process.platform,
+    arch: getArch(),
+  })
+
+  const distDir = path.join(ELECTRON_DIR, 'dist')
+  fs.rmSync(distDir, { recursive: true, force: true })
+  fs.rmSync(path.join(ELECTRON_DIR, 'path.txt'), { force: true })
+  // Fresh binary — let rebrand-electron.js run again
+  fs.rmSync(SENTINEL, { force: true })
+  fs.mkdirSync(distDir, { recursive: true })
+  unzip(zipPath, distDir)
+
+  // Same housekeeping as electron/install.js
+  const srcTypeDefs = path.join(distDir, 'electron.d.ts')
+  if (fs.existsSync(srcTypeDefs)) {
+    fs.renameSync(srcTypeDefs, path.join(ELECTRON_DIR, 'electron.d.ts'))
+  }
+
+  if (!fs.existsSync(path.join(distDir, platformPath))) {
+    throw new Error(`binary missing after extract: dist/${platformPath}`)
+  }
+  fs.writeFileSync(path.join(ELECTRON_DIR, 'path.txt'), platformPath)
+}
+
+// ─── Entry ──────────────────────────────────────────
+
+if (require.main === module) {
+  extractElectron().then(
+    () => process.exit(0),
+    (err) => {
+      console.error(`[ctlsurf] Electron extract failed: ${err.message}`)
+      process.exit(1)
+    }
+  )
+}
+
+module.exports = { extractElectron }

package/src/main/headless.ts

@@ -31,6 +31,7 @@ import { Orchestrator } from './orchestrator'
 import { getSettingsDir } from './settingsDir'
 import { getBuiltinAgents, getAvailableAgents, isCodingAgent, type AgentConfig } from './agents'
 import { Tui } from './tui'
+import { ResourceMonitor, summarizeSnapshot } from './monitor'
 import { fetchLatestNpmVersion, compareSemver, NPM_PACKAGE } from './updateCheck'
 
 function getCurrentVersion(): string {
@@ -177,6 +178,16 @@ async function main() {
   await orchestrator.spawnAgent(HEADLESS_TAB, agent, args.cwd, { trackTime: trackTimeOverride })
   orchestrator.resizePty(HEADLESS_TAB, ptySize.cols, ptySize.rows)
 
+  // CPU / RAM and the agent's plan quota, appended to the tab title.
+  const monitor = new ResourceMonitor(() => orchestrator.getTabProcesses())
+  const refreshResources = () => {
+    monitor.snapshot()
+      .then(snap => tui.update({ resources: summarizeSnapshot(snap) }))
+      .catch(() => { /* keep the last title */ })
+  }
+  refreshResources()
+  setInterval(refreshResources, 10_000).unref()
+
   // For coding agents, send an initial prompt to kick-start them
   if (isCodingAgent(agent)) {
     setTimeout(() => {
@@ -221,6 +232,7 @@ async function main() {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false)
     }
+    monitor.stop()
     tui.destroy()
     await orchestrator.shutdown()
     process.exit(0)

package/src/main/index.ts

@@ -27,6 +27,7 @@ import { getSettingsDir } from './settingsDir'
 import { Orchestrator } from './orchestrator'
 import { AttentionController } from './agentState'
 import { listSshHosts, getRecentHosts, addRecentHost, probeRemote, buildRemoteAgent, type RemoteAction } from './ssh'
+import { ResourceMonitor } from './monitor'
 
 const SETTINGS_DIR = getSettingsDir(true)
 
@@ -498,6 +499,12 @@ async function checkForUpdate(): Promise<void> {
 ipcMain.handle('app:getVersion', () => app.getVersion())
 ipcMain.handle('app:getUpdateInfo', () => updateInfo)
 
+// ─── Resources + plan quota (status bar) ──────────
+
+// Samples only while the renderer keeps asking; `fast` = the panel is open.
+const resourceMonitor = new ResourceMonitor(() => orchestrator.getTabProcesses())
+ipcMain.handle('monitor:snapshot', (_event, fast: boolean) => resourceMonitor.snapshot(!!fast))
+
 // ─── Filesystem IPC ───────────────────────────────
 
 ipcMain.handle('fs:readDir', async (_event, dirPath: string) => {
@@ -831,6 +838,7 @@ let shutdownStarted = false
 function shutdownThenQuit(): void {
   if (shutdownStarted) return
   shutdownStarted = true
+  resourceMonitor.stop()
   void Promise.race([
     orchestrator.shutdown(),
     new Promise((resolve) => setTimeout(resolve, 10_000)),