claude-code-session-manager 0.8.6 → 0.10.0

package/src/main/sessionsStore.cjs

@@ -15,6 +15,7 @@ const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
 const { ipcMain } = require('electron');
+const config = require('./config.cjs');
 
 function storePath() {
   return path.join(os.homedir(), '.config', 'session-manager', 'tabs.json');
@@ -38,14 +39,9 @@ async function load() {
 }
 
 async function save({ tabs, activeTabId, freshStart }) {
-  const p = storePath();
-  await fsp.mkdir(path.dirname(p), { recursive: true }).catch(() => {});
   const payload = { tabs, activeTabId, savedAt: Date.now() };
   if (freshStart) payload.freshStart = true;
-  const body = JSON.stringify(payload, null, 2) + '\n';
-  const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await fsp.writeFile(tmp, body, 'utf8');
-  await fsp.rename(tmp, p);
+  await config.writeJson(storePath(), payload);
   return { ok: true };
 }
 

package/src/main/supervisor.cjs

@@ -16,6 +16,7 @@ const path = require('node:path');
 const os = require('node:os');
 const { spawn, execFileSync } = require('node:child_process');
 const { ipcMain } = require('electron');
+const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 
 const HOME = os.homedir();
 const SUPERVISOR_LOG_PATH = path.join(HOME, '.claude', 'session-manager', 'supervisor.log');
@@ -27,7 +28,6 @@ const inFlightProbes = new Set();
 
 let supervisorInterval = null;
 let _readQueue = null;
-let _mutate = null;
 
 // ─── /proc helpers (Linux-only) ────────────────────────────────────────────
 
@@ -101,20 +101,7 @@ function getChildBashCmdlines(jobPid) {
 
 // ─── Log tail helpers ───────────────────────────────────────────────────────
 
-function readTailBytes(filePath, bytes) {
-  try {
-    const stat = fs.statSync(filePath);
-    const n = Math.min(stat.size, bytes);
-    if (n <= 0) return '';
-    const fd = fs.openSync(filePath, 'r');
-    const buf = Buffer.alloc(n);
-    fs.readSync(fd, buf, 0, n, stat.size - n);
-    fs.closeSync(fd);
-    return buf.toString('utf8');
-  } catch {
-    return '';
-  }
-}
+const { readTail: readTailBytes } = require('./lib/fileTail.cjs');
 
 /**
  * Skim the last 16 KB of a run log for the most recent assistant/user/result
@@ -178,24 +165,6 @@ function readSupervisorLog(n) {
   }
 }
 
-// ─── Claude binary resolution ────────────────────────────────────────────────
-
-let claudeBinCached = null;
-function resolveClaudeBin() {
-  if (claudeBinCached) return claudeBinCached;
-  const candidates = [
-    path.join(HOME, '.claude', 'local', 'claude'),
-    '/usr/local/bin/claude',
-    '/opt/homebrew/bin/claude',
-    '/usr/bin/claude',
-  ];
-  for (const c of candidates) {
-    try { fs.accessSync(c, fs.constants.X_OK); claudeBinCached = c; return c; } catch { /* */ }
-  }
-  claudeBinCached = 'claude';
-  return claudeBinCached;
-}
-
 // ─── Probe ──────────────────────────────────────────────────────────────────
 
 function buildProbePrompt({ slug, cwd, startedAt, ageMinutes, lastActivityAge, jobPid, pstreeOutput, childBashCmdlines, logTail }) {
@@ -454,7 +423,7 @@ async function supervisorTick() {
 
 // ─── Lifecycle ───────────────────────────────────────────────────────────────
 
-function startSupervisor({ readQueue, mutate }) {
+function startSupervisor({ readQueue }) {
   if (process.platform !== 'linux') {
     console.log('[supervisor] non-Linux platform detected; supervisor is a no-op for v1');
     return;
@@ -465,7 +434,6 @@ function startSupervisor({ readQueue, mutate }) {
   }
 
   _readQueue = readQueue;
-  _mutate = mutate;
 
   stopSupervisor(); // idempotent: clear any existing interval
 

package/src/main/teams.cjs

@@ -0,0 +1,95 @@
+/**
+ * Teams enumerator — surfaces ~/.claude/teams/<name>/ to the renderer.
+ *
+ * Each team is a directory containing:
+ *   - config.json: { name, description?, members: [{ name, agentType, model, cwd?, ... }], ... }
+ *   - inboxes/<thread>.json: one file per pending message thread (depth = file count)
+ *
+ * We treat teams as feature-flagged: enabled when env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS === "1"
+ * is set in merged Claude settings. The renderer does its own check; this
+ * handler always returns the on-disk roster so the UI can keep recovering
+ * gracefully even if settings are unparseable.
+ *
+ * All reads route through config.cjs (validatePath + atomic semantics).
+ * Complexity: O(T·M) where T = teams and M = members; both are small (< 20).
+ */
+
+const { ipcMain } = require('electron');
+const os = require('node:os');
+const path = require('node:path');
+const configMgr = require('./config.cjs');
+const logs = require('./logs.cjs');
+
+const TEAMS_ROOT = path.join(os.homedir(), '.claude', 'teams');
+
+/**
+ * Enumerate teams. Returns { teams: TeamInfo[] }.
+ * Failures per-team (unreadable config.json, missing inbox dir) are swallowed —
+ * the team is included with whatever data we could recover. The renderer
+ * decides how to render incomplete entries.
+ */
+async function listTeams() {
+  let dir;
+  try {
+    dir = await configMgr.listDir(TEAMS_ROOT, { dirsOnly: true });
+  } catch {
+    // listDir throws when path is outside allowed boundaries — should not
+    // happen for ~/.claude/teams, but guard anyway.
+    return { teams: [] };
+  }
+  if (!dir.ok) {
+    if (dir.error) logs.writeLine({ level: 'warn', scope: 'teams', message: 'listDir failed', meta: { error: dir.error } });
+    return { teams: [] };
+  }
+  if (dir.entries.length === 0) return { teams: [] };
+
+  const teams = [];
+  for (const entry of dir.entries) {
+    const teamName = entry.name;
+    const configPath = path.join(entry.path, 'config.json');
+    const inboxDir = path.join(entry.path, 'inboxes');
+
+    let config = null;
+    try {
+      const r = await configMgr.readJson(configPath);
+      if (r.exists && !r.parseError) config = r.data;
+    } catch { /* unreadable — leave config null */ }
+
+    let inboxDepth = 0;
+    try {
+      const inbox = await configMgr.listDir(inboxDir, { filesOnly: true });
+      if (inbox.ok) {
+        inboxDepth = inbox.entries.filter((f) => f.name.endsWith('.json')).length;
+      }
+    } catch { /* no inbox dir is fine */ }
+
+    const members = Array.isArray(config?.members)
+      ? config.members.map((m) => ({
+          name: typeof m?.name === 'string' ? m.name : 'unnamed',
+          agentType: typeof m?.agentType === 'string' ? m.agentType : null,
+          model: typeof m?.model === 'string' ? m.model : null,
+        }))
+      : [];
+
+    teams.push({
+      name: teamName,
+      configPath,
+      description: typeof config?.description === 'string' ? config.description : null,
+      leadAgentId: typeof config?.leadAgentId === 'string' ? config.leadAgentId : null,
+      members,
+      memberCount: members.length,
+      inboxDepth,
+    });
+  }
+  return { teams };
+}
+
+function registerTeamsHandlers() {
+  ipcMain.handle('teams:list', () => listTeams());
+}
+
+module.exports = {
+  registerTeamsHandlers,
+  // exported for direct use / tests
+  listTeams,
+};

package/src/main/transcripts.cjs

@@ -24,6 +24,8 @@ const path = require('node:path');
 const os = require('node:os');
 const chokidar = require('chokidar');
 const otel = require('./otel.cjs');
+const logs = require('./logs.cjs');
+const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 
 let window = null;
 
@@ -34,9 +36,7 @@ function attachWindow(w) {
   window = w;
 }
 
-function encodeCwd(cwd) {
-  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
-}
+const { encodeCwd } = require('./lib/encodeCwd.cjs');
 
 function transcriptPath(cwd, sessionUuid) {
   return path.join(os.homedir(), '.claude', 'projects', encodeCwd(cwd), `${sessionUuid}.jsonl`);
@@ -135,9 +135,7 @@ async function flush(sub, { emit = true } = {}) {
     // Ring buffer (cap at 500 entries to bound memory).
     sub.buffer.push(ev);
     if (sub.buffer.length > 500) sub.buffer.shift();
-    if (emit && window && !window.isDestroyed()) {
-      window.webContents.send(`transcript:event:${sub.tabId}`, ev);
-    }
+    if (emit) sendIfAlive(window, `transcript:event:${sub.tabId}`, ev);
     // Mirror to OTEL — no-op when disabled. We emit on the initial drain too
     // so backfilled transcripts show up in the trace store.
     otel.recordTranscriptEvent({
@@ -184,7 +182,7 @@ async function subscribe({ tabId, cwd, sessionUuid }) {
   });
   watcher.on('add', () => flush(sub).catch(() => {}));
   watcher.on('change', () => flush(sub).catch(() => {}));
-  watcher.on('error', (err) => console.warn('[transcripts] watcher error:', err.message));
+  watcher.on('error', (err) => logs.writeLine({ level: 'warn', scope: 'transcripts', message: 'chokidar watcher error', meta: { error: err?.message } }));
   sub.watcher = watcher;
   subs.set(tabId, sub);
   return { ok: true, path: filePath };

package/src/main/usage.cjs

@@ -24,6 +24,10 @@ const { refreshIfNeeded, expiresAtMs } = require('./lib/credentials.cjs');
 
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const CACHE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'billing-cache.json');
+// Coalesce the 4 renderer pollers (Overview/AppStatusBar/StatusBar/Usage). A
+// fresh ok-cache is served directly without touching the network. Auth/
+// transient/config skip this TTL so they retry promptly on next poll.
+const OK_CACHE_TTL_MS = 30_000;
 
 /**
  * Pure: classify a raw HTTP response status + body from the usage endpoint into a
@@ -140,6 +144,10 @@ function registerBillingHandlers() {
   ipcMain.handle('billing:fetch', async () => {
     if (hydrationPromise) { await hydrationPromise; hydrationPromise = null; }
 
+    if (cache && cache.fetchedAt && Date.now() - cache.fetchedAt < OK_CACHE_TTL_MS) {
+      return { kind: 'ok', data: cache.data };
+    }
+
     const r = await fetchUsage();
     if (r.kind === 'ok') {
       cache = { data: r.data, fetchedAt: Date.now(), sourceCredsExpiresAt: r.data.credentialsExpiresAt };

package/src/main/voiceHotkey.cjs

@@ -18,6 +18,7 @@
 const { app, globalShortcut, ipcMain } = require('electron');
 const voiceSettings = require('./voiceSettings.cjs');
 const { voiceHotkeyLog } = require('./lib/voice-hotkey-log.cjs');
+const { schemas, validated } = require('./ipcSchemas.cjs');
 
 let mainWindow = null;
 let currentConfig = null;
@@ -297,7 +298,9 @@ function registerHotkeyHandlers() {
     return currentConfig;
   });
 
-  ipcMain.handle('voice:set-hotkey', async (_e, cfg) => {
+  ipcMain.handle('voice:set-hotkey', validated(schemas.voiceSetHotkey, async (cfg) => {
+    // voiceSettings.isValidConfig adds one cross-field check zod can't express
+    // tersely (global=true + mode=hold is rejected, see PRD F1 v2). Keep it.
     if (!voiceSettings.isValidConfig(cfg)) {
       throw new Error('Invalid voice hotkey config');
     }
@@ -308,7 +311,7 @@ function registerHotkeyHandlers() {
       mainWindow.webContents.send('voice:hotkey-changed', currentConfig);
     }
     return { ok: true, config: currentConfig };
-  });
+  }));
 
   ipcMain.handle('voice:get-hotkey-config-path', () => voiceSettings.storePath());
 
@@ -317,20 +320,21 @@ function registerHotkeyHandlers() {
     return await voiceSettings.loadDevice();
   });
 
-  ipcMain.handle('voice:set-device-pref', async (_e, pref) => {
-    if (!voiceSettings.isValidDevicePref(pref)) {
-      throw new Error('Invalid device pref payload');
-    }
+  ipcMain.handle('voice:set-device-pref', validated(schemas.voiceSetDevicePref, async (pref) => {
     await voiceSettings.saveDevice(pref);
     return { ok: true };
-  });
+  }));
 
   // Renderer pings this when isRecording flips so we can prefix the window
-  // title with `● REC — ` (PRD F1 v2 §Security: privacy invariant).
+  // title with `● REC — ` (PRD F1 v2 §Security: privacy invariant). This is
+  // `ipcMain.on` (not handle), so we can't use the validated() helper —
+  // safeParse inline and silently drop malformed payloads.
   ipcMain.on('voice:set-recording', (_e, recording) => {
+    const parsed = schemas.voiceSetRecording.safeParse(recording);
+    if (!parsed.success) return;
     if (!mainWindow || mainWindow.isDestroyed()) return;
     const baseTitle = 'Claude Session Manager';
-    const next = recording ? `● REC — ${baseTitle}` : baseTitle;
+    const next = parsed.data ? `● REC — ${baseTitle}` : baseTitle;
     try { mainWindow.setTitle(next); } catch { /* */ }
   });
 }

package/src/main/voiceSettings.cjs

@@ -24,6 +24,7 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
+const config = require('./config.cjs');
 
 const SCHEMA_VERSION = 1;
 const DEVICE_SCHEMA_VERSION = 1;
@@ -103,17 +104,9 @@ async function readRaw() {
 let writeQueue = Promise.resolve();
 async function writeMerged(patch) {
   const run = async () => {
-    const p = storePath();
-    await fsp.mkdir(path.dirname(p), { recursive: true }).catch(() => {});
     const existing = (await readRaw()) || {};
     const next = { ...existing, ...patch };
-    const body = JSON.stringify(next, null, 2) + '\n';
-    const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-    await fsp.writeFile(tmp, body, { encoding: 'utf8', mode: 0o600 });
-    // chmod tmp explicitly because some platforms ignore the mode arg on
-    // writeFile when the file pre-exists. Then rename for atomicity.
-    try { await fsp.chmod(tmp, 0o600); } catch { /* */ }
-    await fsp.rename(tmp, p);
+    await config.writeTextAtomic(storePath(), JSON.stringify(next, null, 2) + '\n', { mode: 0o600 });
     return { ok: true };
   };
   // Tail-promise pattern: each call awaits the previous, so writes are

package/src/main/voiceWizard.cjs

@@ -1,10 +1,9 @@
 /**
  * voiceWizard — F7 first-run mic-check wizard, main-process side.
  *
- * Owns three IPC channels:
+ * Owns:
  *   - voice:wizard-state   → returns persisted state + current schema constant
  *   - voice:wizard-complete → stamps completedAt + completedSchema to voice.json
- *   - app:is-e2e           → exposes process.env.SM_E2E === '1' to the renderer
  *
  * No window state held here; persistence is delegated to voiceSettings.cjs
  * (additive `wizard` subtree on the same file as F1/F5).
@@ -12,6 +11,7 @@
 
 const { ipcMain } = require('electron');
 const voiceSettings = require('./voiceSettings.cjs');
+const { schemas, validated } = require('./ipcSchemas.cjs');
 
 function registerWizardHandlers() {
   ipcMain.handle('voice:wizard-state', async () => {
@@ -32,23 +32,16 @@ function registerWizardHandlers() {
     return { ok: true, ...next, currentSchema: voiceSettings.WIZARD_SCHEMA };
   });
 
-  // E2E plumbing: tests set SM_E2E=1 to suppress the wizard auto-trigger.
-  // The renderer reads this once on mount.
-  ipcMain.handle('app:is-e2e', () => process.env.SM_E2E === '1');
-
   // F8 — turn-detector settings (additive subtree on voice.json).
   // MVP: persistence only; no model loaded in v1 (see PRD §Loading & inference).
   ipcMain.handle('voice:get-turn-detector', async () => {
     return await voiceSettings.loadTurnDetector();
   });
 
-  ipcMain.handle('voice:set-turn-detector', async (_e, state) => {
-    if (!voiceSettings.isValidTurnDetectorState(state)) {
-      throw new Error('Invalid turn-detector state payload');
-    }
+  ipcMain.handle('voice:set-turn-detector', validated(schemas.voiceSetTurnDetector, async (state) => {
     await voiceSettings.saveTurnDetector(state);
     return { ok: true, state: await voiceSettings.loadTurnDetector() };
-  });
+  }));
 }
 
 module.exports = { registerWizardHandlers };

package/src/main/watchers.cjs

@@ -15,6 +15,8 @@ const path = require('node:path');
 const os = require('node:os');
 const fs = require('node:fs');
 const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+const { assertCwdInsideHome } = require('./lib/insideHome.cjs');
+const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 
 // Splits a readable stream into lines capped at maxLineBytes. Prevents OOM
 // from commands that produce no newlines (e.g. cat /dev/urandom | base64).
@@ -59,17 +61,8 @@ class WatcherManager {
   add({ tabId, label, command, cwd }) {
     const resolvedCwd = cwd || process.cwd();
 
-    // Require cwd's realpath to be inside homedir.
-    const home = os.homedir();
-    let realCwd;
-    try {
-      realCwd = fs.realpathSync(resolvedCwd);
-    } catch {
-      realCwd = path.resolve(resolvedCwd);
-    }
-    if (realCwd !== home && !realCwd.startsWith(home + path.sep)) {
-      throw new Error(`watcher cwd outside home directory: ${realCwd}`);
-    }
+    const r = assertCwdInsideHome(resolvedCwd);
+    if (!r.ok) throw new Error(`watcher ${r.error}`);
 
     const watcherId = crypto.randomUUID();
     const trimmedLabel = (label && label.trim()) || command.slice(0, 40);
@@ -95,14 +88,12 @@ class WatcherManager {
 
     const emitLine = (line) => {
       entry.lineCount++;
-      if (this.window && !this.window.isDestroyed()) {
-        this.window.webContents.send('watcher:line', {
-          tabId,
-          watcherId,
-          line,
-          ts: Date.now(),
-        });
-      }
+      sendIfAlive(this.window, 'watcher:line', {
+        tabId,
+        watcherId,
+        line,
+        ts: Date.now(),
+      });
     };
 
     lineSplit(child.stdout, emitLine);
@@ -119,9 +110,7 @@ class WatcherManager {
       if (this.watchers.has(watcherId)) {
         emitLine(`[exited code=${code ?? 'null'}${signal ? ` signal=${signal}` : ''}]`);
         this.watchers.delete(watcherId);
-        if (this.window && !this.window.isDestroyed()) {
-          this.window.webContents.send('watcher:closed', { tabId, watcherId });
-        }
+        sendIfAlive(this.window, 'watcher:closed', { tabId, watcherId });
       }
     });
 
@@ -164,9 +153,7 @@ class WatcherManager {
     setTimeout(() => {
       try { if (w.child.exitCode === null && w.child.signalCode === null) w.child.kill('SIGKILL'); } catch { /* */ }
     }, 2000).unref?.();
-    if (this.window && !this.window.isDestroyed()) {
-      this.window.webContents.send('watcher:closed', { tabId: w.tabId, watcherId });
-    }
+    sendIfAlive(this.window, 'watcher:closed', { tabId: w.tabId, watcherId });
     return { ok: true };
   }
 
@@ -186,27 +173,16 @@ function attachWindow(window) {
 }
 
 function registerWatcherHandlers() {
-  const { z } = require('zod');
-  const addSchema = z.object({
-    tabId: z.string().min(1).max(128),
-    label: z.string().max(256).optional().default(''),
-    command: z.string().min(1).max(8192),
-    cwd: z.string().max(4096).optional().nullable(),
-  });
-  const listSchema = z.object({ tabId: z.string().min(1).max(128) });
-  const removeSchema = z.object({ watcherId: z.string().min(1).max(128) });
-  const killTabSchema = z.object({ tabId: z.string().min(1).max(128) });
-
-  ipcMain.handle('watchers:add', (_e, payload) => manager.add(addSchema.parse(payload)));
-  ipcMain.handle('watchers:list', (_e, payload) => manager.list(listSchema.parse(payload)));
-  ipcMain.handle('watchers:remove', (_e, payload) => manager.remove(removeSchema.parse(payload)));
-  ipcMain.handle('watchers:kill-tab', (_e, payload) => {
-    const { tabId } = killTabSchema.parse(payload);
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('watchers:add', v(s.watchersAdd, (payload) => manager.add(payload)));
+  ipcMain.handle('watchers:list', v(s.watchersList, (payload) => manager.list(payload)));
+  ipcMain.handle('watchers:remove', v(s.watchersRemove, (payload) => manager.remove(payload)));
+  ipcMain.handle('watchers:kill-tab', v(s.watchersKillTab, ({ tabId }) => {
     for (const [id, w] of manager.watchers) {
       if (w.tabId === tabId) manager.remove({ watcherId: id });
     }
     return { ok: true };
-  });
+  }));
 }
 
 module.exports = { manager, attachWindow, registerWatcherHandlers };