claude-code-session-manager 0.29.0 → 0.31.0

package/dist/index.html

@@ -7,7 +7,7 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-qS7GdCsL.js"></script>
+    <script type="module" crossorigin src="./assets/index-hreMRE8u.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
     <link rel="stylesheet" crossorigin href="./assets/index-DMIi9YZH.css">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -11,6 +11,7 @@
     "bin/",
     ".claude-plugin/",
     "plugins/",
+    "scripts/postinstall.cjs",
     "src/main/",
     "src/preload/",
     "dist/index.html",
@@ -26,7 +27,7 @@
     "build": "vite build",
     "typecheck": "tsc --noEmit",
     "start": "electron .",
-    "postinstall": "electron-rebuild -f -w node-pty",
+    "postinstall": "node scripts/postinstall.cjs",
     "prepublishOnly": "vite build",
     "test:unit": "vitest run",
     "test:verify": "node src/main/__tests__/runVerify.test.cjs",

package/scripts/postinstall.cjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * postinstall — rebuild node-pty against the bundled Electron's ABI.
+ *
+ * The terminal needs node-pty's native binary to match the Electron we ship.
+ * We run electron-rebuild, but a failure here MUST NOT fail `npm i -g` — that
+ * would block the entire app (config tabs, scheduler, etc.) over one native
+ * module. So we run it best-effort and, on failure, print the exact manual fix
+ * and exit 0. pty.cjs surfaces the same guidance in-app if a tab can't start.
+ */
+
+const { spawnSync } = require('node:child_process');
+
+function run() {
+  const r = spawnSync(
+    process.platform === 'win32' ? 'npx.cmd' : 'npx',
+    ['electron-rebuild', '-f', '-w', 'node-pty'],
+    { stdio: 'inherit' },
+  );
+  return r.status === 0 && !r.error;
+}
+
+if (run()) process.exit(0);
+
+const mac = process.platform === 'darwin';
+const bar = '─'.repeat(64);
+console.warn(`\n${bar}`);
+console.warn('claude-code-session-manager: node-pty rebuild did not complete.');
+console.warn('The app will still launch, but terminal tabs may not start until');
+console.warn('the native module is rebuilt for this Electron. To fix it:');
+console.warn('');
+console.warn('  cd "' + __dirname.replace(/\/scripts$/, '') + '"');
+console.warn('  npx electron-rebuild -f -w node-pty');
+if (mac) {
+  console.warn('');
+  console.warn('  # macOS: if the rebuild fails, install the compiler first:');
+  console.warn('  xcode-select --install');
+}
+console.warn(`${bar}\n`);
+// Exit 0 — never fail the install over the terminal native module.
+process.exit(0);

package/src/main/kg.cjs

@@ -51,6 +51,11 @@ const BATCH = 20;                 // prompts per extraction call (also a per-pro
 const KNOWN_VOCAB = 200;          // top node names pre-seeded for dedup-at-extraction
 const MAX_TAIL_BYTES = 8 * 1024 * 1024;   // bound bytes scanned per ingest run
 const MAX_EXTRACTIONS_PER_RUN = 30;       // bound claude calls per run (cost/time)
+// prompts.jsonl is append-only and otherwise grows forever (observed 325 MB).
+// Once we're caught up past this size, rotate it to prompts.jsonl.1 (one backup
+// kept) and reset the cursor — extraction only ever needs the new tail, and the
+// already-extracted prompts live in the per-project graphs.
+const MAX_LOG_BYTES = 256 * 1024 * 1024;
 // Coalescing window before an auto-ingest after new prompts land. Units never
 // mix projects, and a project switch in the log closes the current batch — so
 // with concurrent sessions a short window yields 1-2-prompt batches and one
@@ -159,6 +164,30 @@ async function saveIngestState(s) {
   await writeJson(INGEST_STATE_PATH, s);
 }
 
+/**
+ * Rotate prompts.jsonl once it grows past MAX_LOG_BYTES. Only call when caught
+ * up (lastOffset >= size) so no unconsumed prompts are lost. Renames to a single
+ * `.1` backup (overwriting any prior one) and resets the cursor to 0; the
+ * UserPromptSubmit hook recreates prompts.jsonl on its next append. Best-effort:
+ * a failure leaves the log in place and is retried on the next caught-up cycle.
+ */
+async function rotateLogIfTooLarge(st, stat) {
+  if (!stat || stat.size < MAX_LOG_BYTES) return false;
+  const rotated = LOG_PATH + '.1';
+  try {
+    try { await fsp.unlink(rotated); } catch { /* no prior backup */ }
+    await fsp.rename(LOG_PATH, rotated);
+    st.lastOffset = 0;
+    st.updatedAt = new Date().toISOString();
+    await saveIngestState(st);
+    logger.writeLine({ scope: 'kg', level: 'info', message: 'rotated prompts.jsonl', meta: { rotatedBytes: stat.size, backup: rotated } });
+    return true;
+  } catch (e) {
+    logger.writeLine({ scope: 'kg', level: 'warn', message: 'log rotation failed', meta: { error: e?.message } });
+    return false;
+  }
+}
+
 /**
  * Per-project prompt-count sidecar: { [encodedCwd]: { count: number, cwd: string } }
  * Returns null when the file does not yet exist (triggers a one-time migration scan).
@@ -356,7 +385,19 @@ async function ingest() {
     try { stat = await fsp.stat(LOG_PATH); }
     catch { broadcast('kg:ingest-progress', { phase: 'done', ingesting: false, added: 0 }); return { ok: true, added: 0, note: 'no log yet' }; }
 
+    // Truncation/rotation recovery: if the log shrank below our watermark it was
+    // rotated or truncated out from under us — restart from the top of the new
+    // file rather than wedging forever at a stale offset.
+    if (stat.size < st.lastOffset) {
+      logger.writeLine({ scope: 'kg', level: 'info', message: 'log shrank; resetting ingest cursor', meta: { size: stat.size, lastOffset: st.lastOffset } });
+      st.lastOffset = 0;
+      st.updatedAt = new Date().toISOString();
+      await saveIngestState(st);
+    }
+
     if (stat.size <= st.lastOffset) {
+      // Caught up — a safe moment to rotate the log if it has grown too large.
+      await rotateLogIfTooLarge(st, stat);
       broadcast('kg:ingest-progress', { phase: 'done', ingesting: false, added: 0 });
       return { ok: true, added: 0, note: 'up to date' };
     }

package/src/main/lib/cleanEnv.cjs

@@ -1,5 +1,36 @@
+const os = require('node:os');
+const path = require('node:path');
+
 const SECRET_KEY_RE = /^(?:.*_)?(TOKEN|API_?KEY|SECRET|PASSWORD|AUTHORIZATION|COOKIE|REFRESH[_-]?TOKEN|ACCESS[_-]?TOKEN)$/i;
 
+/**
+ * Common user + Homebrew bin dirs to PREPEND to a spawned child's PATH.
+ * Electron can launch from Finder/Dock with a stripped PATH, and Apple Silicon
+ * Homebrew lives under /opt/homebrew — without these, `claude`, git, node, etc.
+ * are invisible to ptys and `claude -p` jobs on macOS. Single source of truth
+ * so pty.cjs and pluginInstall.cjs can't drift (one of them was missing
+ * /opt/homebrew and broke plugin install on Apple Silicon).
+ */
+function userBinDirs() {
+  const home = os.homedir();
+  return [
+    path.join(home, '.claude', 'local'),
+    path.join(home, '.local', 'bin'),
+    path.join(home, '.npm-global', 'bin'),
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+  ];
+}
+
+/** Electron's PATH prefixed with the user/Homebrew bin dirs — the value to put
+ *  in a spawned child's PATH so `claude`, node, git, etc. resolve on macOS. */
+function pathWithUserBins() {
+  return `${userBinDirs().join(':')}:${process.env.PATH || ''}`;
+}
+
 function cleanChildEnv(extra = {}) {
   const env = { ...process.env, ...extra };
   for (const k of Object.keys(env)) {
@@ -17,4 +48,4 @@ function cleanChildEnv(extra = {}) {
   return env;
 }
 
-module.exports = { cleanChildEnv };
+module.exports = { cleanChildEnv, userBinDirs, pathWithUserBins };

package/src/main/lib/credentials.cjs

@@ -5,7 +5,8 @@ const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const { spawn, execFileSync } = require('node:child_process');
-const { cleanChildEnv } = require('./cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./cleanEnv.cjs');
+const { resolveClaudeBin } = require('./claudeBin.cjs');
 
 const CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
 
@@ -185,7 +186,12 @@ function tryCliFallback() {
     const timer = setTimeout(() => settle({ ok: false, reason: 'timeout' }), 15_000);
     let child;
     try {
-      child = spawn('claude', ['--version'], { stdio: 'ignore', env: cleanChildEnv() });
+      // Resolve the absolute binary + inject Homebrew/user bins so this works
+      // even when Electron launched from Finder/Dock with a stripped PATH (mac).
+      child = spawn(resolveClaudeBin(), ['--version'], {
+        stdio: 'ignore',
+        env: cleanChildEnv({ PATH: pathWithUserBins() }),
+      });
     } catch (e) {
       clearTimeout(timer);
       return settle({ ok: false, reason: e?.message });

package/src/main/pluginInstall.cjs

@@ -21,7 +21,7 @@ const pty = require('node-pty');
 const path = require('node:path');
 const os = require('node:os');
 const fs = require('node:fs');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { schemas } = require('./ipcSchemas.cjs');
@@ -58,16 +58,8 @@ function send(channel, payload) {
 }
 
 function childEnv() {
-  const home = os.homedir();
-  const extraPath = [
-    path.join(home, '.local', 'bin'),
-    path.join(home, '.npm-global', 'bin'),
-    '/usr/local/bin',
-    '/usr/bin',
-    '/bin',
-  ].join(':');
   return cleanChildEnv({
-    PATH: `${extraPath}:${process.env.PATH || ''}`,
+    PATH: pathWithUserBins(),
     TERM: 'xterm-256color',
     FORCE_COLOR: '0', // strip ANSI so the renderer doesn't have to.
   });

package/src/main/pty.cjs

@@ -1,13 +1,57 @@
-const pty = require('node-pty');
+// Load the native node-pty lazily-guarded: if its prebuilt/rebuilt binary
+// doesn't match this Electron's ABI, a bare top-level require would throw and
+// crash the WHOLE app at startup (index.cjs requires this module). Instead we
+// capture the error and surface an actionable message when a tab is opened, so
+// the app still boots and the user sees exactly how to fix the terminal.
+let pty = null;
+let ptyLoadError = null;
+try {
+  pty = require('node-pty');
+} catch (e) {
+  ptyLoadError = e;
+  // eslint-disable-next-line no-console
+  console.error('[pty] node-pty failed to load:', e?.message);
+}
 const { ipcMain } = require('electron');
 const path = require('node:path');
 const os = require('node:os');
 const fs = require('node:fs');
 const { addAllowedRoot } = require('./config.cjs');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const { checkInsideHome } = require('./lib/insideHome.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 
+// Absolute path to the installed package root (src/main/ -> ../../), shown in
+// the remediation message so the user can cd there and rebuild.
+const PKG_DIR = path.join(__dirname, '..', '..');
+
+/**
+ * ANSI-formatted terminal text explaining a native-module / immediate-exit
+ * failure and exactly how to fix it. Written straight into the tab's output so
+ * a dead terminal explains itself instead of just going blank.
+ */
+function nativeModuleHelp(reason) {
+  const mac = process.platform === 'darwin';
+  const lines = [
+    '',
+    `\x1b[1;33m[session-manager] Terminal could not start.\x1b[0m`,
+    `\x1b[33m${reason}\x1b[0m`,
+    '',
+    `This is almost always the node-pty native module not matching this`,
+    `Electron build. Rebuild it once:`,
+    '',
+    `  \x1b[36mcd ${PKG_DIR}\x1b[0m`,
+    `  \x1b[36mnpx electron-rebuild -f -w node-pty\x1b[0m`,
+    '',
+    mac ? `macOS: if the rebuild fails, install the compiler first:` : '',
+    mac ? `  \x1b[36mxcode-select --install\x1b[0m` : '',
+    mac ? '' : '',
+    `Then quit and reopen session-manager.`,
+    '',
+  ].filter((l) => l !== '');
+  return lines.join('\r\n') + '\r\n';
+}
+
 /**
  * PtyManager — owns every claude PTY process, keyed by tabId (renderer-generated UUID).
  * Streams output to the renderer via IPC channels scoped by tabId.
@@ -26,6 +70,15 @@ class PtyManager {
   spawn({ tabId, cwd, cols = 120, rows = 30 }) {
     console.log('[pty] spawn requested', { tabId });
 
+    // Native module unavailable — explain in the tab and report a clean exit
+    // rather than throwing (which would surface as an opaque IPC error).
+    if (!pty || ptyLoadError) {
+      const reason = `node-pty failed to load: ${ptyLoadError?.message ?? 'module missing'}`;
+      sendIfAlive(this.window, `pty:data:${tabId}`, nativeModuleHelp(reason));
+      setImmediate(() => sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode: 1, signal: undefined }));
+      return { pid: null, cwd, reattached: false, error: 'node-pty unavailable' };
+    }
+
     // Validate that cwd is inside homedir before widening the allowed-root set.
     if (cwd) {
       const r = checkInsideHome(cwd);
@@ -62,18 +115,11 @@ class PtyManager {
       return { pid: existing.proc.pid, cwd: existing.cwd, reattached: true };
     }
 
-    // Prefer `claude` on PATH; extend PATH with common user bin dirs since
-    // Electron can launch with a stripped environment.
-    const extraPath = [
-      path.join(os.homedir(), '.local', 'bin'),
-      path.join(os.homedir(), '.npm-global', 'bin'),
-      '/usr/local/bin',
-      '/usr/bin',
-      '/bin',
-    ].join(':');
-
+    // Prefer `claude` on PATH; extend PATH with common user + Homebrew bin dirs
+    // since Electron can launch with a stripped environment (Apple Silicon
+    // Homebrew is /opt/homebrew, absent from the default Electron PATH).
     const env = cleanChildEnv({
-      PATH: `${extraPath}:${process.env.PATH || ''}`,
+      PATH: pathWithUserBins(),
       TERM: 'xterm-256color',
       COLORTERM: 'truecolor',
       FORCE_COLOR: '1',
@@ -95,11 +141,19 @@ class PtyManager {
       });
     } catch (err) {
       console.error('[pty] pty.spawn threw:', err);
-      throw err;
+      // Surface the cause in the tab + report a clean exit rather than throwing
+      // an opaque IPC error (covers a missing/invalid cwd or a native fault).
+      sendIfAlive(this.window, `pty:data:${tabId}`, nativeModuleHelp(`pty.spawn failed: ${err?.message ?? String(err)}`));
+      setImmediate(() => sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode: 1, signal: undefined }));
+      return { pid: null, cwd, reattached: false, error: String(err?.message || 'spawn-failed') };
     }
     console.log('[pty] spawned pid=', proc.pid, 'for tabId=', tabId);
 
+    const spawnedAt = Date.now();
+    let gotData = false;
+
     proc.onData((data) => {
+      gotData = true;
       sendIfAlive(this.window, `pty:data:${tabId}`, data);
     });
 
@@ -112,11 +166,19 @@ class PtyManager {
         this.sessions.delete(tabId);
         return;
       }
+      // Fast-exit detector: a shell that dies in <1.2s with a non-zero status
+      // and never printed anything almost certainly couldn't exec (broken
+      // node-pty spawn-helper / ABI on macOS). Explain it in the tab instead of
+      // leaving a blank, instantly-closed terminal. Guarded by !gotData so a
+      // real interactive shell (which prints a prompt immediately) is exempt.
+      if (!gotData && exitCode !== 0 && Date.now() - spawnedAt < 1200) {
+        sendIfAlive(this.window, `pty:data:${tabId}`, nativeModuleHelp(`The shell exited immediately (code ${exitCode}).`));
+      }
       sendIfAlive(this.window, `pty:exit:${tabId}`, { exitCode, signal });
       this.sessions.delete(tabId);
     });
 
-    this.sessions.set(tabId, { proc, cwd, created: Date.now() });
+    this.sessions.set(tabId, { proc, cwd, created: spawnedAt });
     return { pid: proc.pid, cwd, reattached: false };
   }
 

package/src/main/scheduler.cjs

@@ -48,7 +48,7 @@ const { randomUUID } = require('node:crypto');
 const { execFile } = require('node:child_process');
 const { ipcMain } = require('electron');
 const billing = require('./usage.cjs');
-const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { cleanChildEnv, pathWithUserBins } = require('./lib/cleanEnv.cjs');
 const supervisor = require('./supervisor.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { readTail } = require('./lib/fileTail.cjs');
@@ -921,7 +921,9 @@ async function executeJob(job, runDir, defaultCwd, onPid) {
     // Strip Claude Code env and secrets that leak in when session-manager is
     // launched from a `claude` shell. CLAUDE_EFFORT=xhigh forces Opus and
     // overrides `--model sonnet`, so scheduled jobs burn Opus credits silently.
-    const childEnv = cleanChildEnv();
+    // PATH must include Homebrew/user bins or the job's node/git children ENOENT
+    // when Electron was launched from Finder/Dock on macOS (stripped PATH).
+    const childEnv = cleanChildEnv({ PATH: pathWithUserBins() });
 
     // Track whether the agent has emitted a `result` event in its JSONL stream.
     // null until seen; then one of "success" | "error_max_turns" | … per the
@@ -1230,7 +1232,7 @@ DO NOT attempt the fix. ONLY write the file. When the file exists, exit immediat
   }
 
   const claudeBin = resolveClaudeBin();
-  const childEnv = cleanChildEnv();
+  const childEnv = cleanChildEnv({ PATH: pathWithUserBins() }); // Homebrew/user bins for macOS
 
   // Investigation needs only a deadman watchdog — no idle-tail or result-tail
   // since investigations are short-running Opus probes with a hard ceiling.