claude-code-session-manager 0.10.0 → 0.10.2

package/src/main/index.cjs

@@ -1,4 +1,4 @@
-const { app, BrowserWindow, ipcMain, dialog, Menu, session, systemPreferences, globalShortcut, shell } = require('electron');
+const { app, BrowserWindow, ipcMain, dialog, Menu, session, systemPreferences, globalShortcut, shell, clipboard } = require('electron');
 const { spawn, execFile, execFileSync } = require('node:child_process');
 const path = require('node:path');
 const fs = require('node:fs');
@@ -24,10 +24,32 @@ const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
 const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs');
 const memoryTool = require('./memoryTool.cjs');
+const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
+const { assertCwdInsideHome } = require('./lib/insideHome.cjs');
 
 let mainWindow = null;
 let rebooting = false;
 
+// Boot diagnostics — populated at app.whenReady so the renderer can poll their
+// state via IPC and surface toasts on the failure paths. The first-paint
+// deadline timer reads these into the boot log if ready-to-show never fires.
+let bootClaudeBin = { resolved: 'claude', foundOnDisk: false };
+let bootHomeSelfCheck = { ok: true };
+const bootRecentIpcInvocations = [];
+let firstPaintTimer = null;
+
+// Wrap ipcMain.handle once to track which channels the renderer actually
+// invokes — the boot log dumps the last 5 so a hang is attributable to a
+// specific handler.
+const originalIpcHandle = ipcMain.handle.bind(ipcMain);
+ipcMain.handle = function trackedHandle(channel, listener) {
+  return originalIpcHandle(channel, (...args) => {
+    bootRecentIpcInvocations.push({ channel, at: new Date().toISOString() });
+    if (bootRecentIpcInvocations.length > 5) bootRecentIpcInvocations.shift();
+    return listener(...args);
+  });
+};
+
 const REBOOT_LOG = path.join(os.homedir(), '.claude', 'session-manager-reboot.log');
 
 function logReboot(line) {
@@ -39,6 +61,52 @@ function logReboot(line) {
   } catch { /* best-effort */ }
 }
 
+// Writes a diagnostic dump when the renderer fails to fire ready-to-show
+// within the boot deadline. Sync I/O is fine — this is the failure path and
+// the user is already staring at a blank window.
+function writeFirstPaintFailureLog() {
+  try {
+    const logDir = path.join(os.homedir(), '.claude', 'session-manager', 'logs');
+    fs.mkdirSync(logDir, { recursive: true });
+
+    const ymd = new Date().toISOString().slice(0, 10);
+    const logPath = path.join(logDir, `boot-${ymd}.log`);
+
+    const homeCheck = assertCwdInsideHome(os.homedir());
+    const lines = [
+      `=== first-paint deadline exceeded @ ${new Date().toISOString()} ===`,
+      `process.versions: ${JSON.stringify(process.versions)}`,
+      `process.platform: ${process.platform}`,
+      `process.arch: ${process.arch}`,
+      `os.homedir(): ${os.homedir()}`,
+      `claudeBin: ${JSON.stringify(bootClaudeBin)}`,
+      `homeSelfCheck: ${JSON.stringify(homeCheck)}`,
+      `recentIpcInvocations: ${JSON.stringify(bootRecentIpcInvocations)}`,
+      'RENDERER DID NOT FIRE ready-to-show WITHIN 10s — likely renderer JS error or main-process IPC hang.',
+      '',
+    ];
+    fs.appendFileSync(logPath, lines.join('\n'), { mode: 0o600 });
+
+    // Keep last 3 boot-*.log files; unlink older ones.
+    try {
+      const entries = fs.readdirSync(logDir)
+        .filter((f) => /^boot-\d{4}-\d{2}-\d{2}\.log$/.test(f))
+        .map((f) => {
+          const full = path.join(logDir, f);
+          let mtimeMs = 0;
+          try { mtimeMs = fs.statSync(full).mtimeMs; } catch { /* */ }
+          return { full, mtimeMs };
+        })
+        .sort((a, b) => b.mtimeMs - a.mtimeMs);
+      for (const e of entries.slice(3)) {
+        try { fs.unlinkSync(e.full); } catch { /* */ }
+      }
+    } catch { /* */ }
+  } catch (err) {
+    console.error('[firstPaint] failed to write boot log:', err?.message);
+  }
+}
+
 function resolveNpx() {
   const isWin = process.platform === 'win32';
   try {
@@ -161,7 +229,14 @@ function createWindow() {
     },
   });
 
+  // Boot-time detection 3: if ready-to-show never fires (blank window from
+  // renderer JS error or main-process IPC hang), write a diagnostic dump so
+  // the user has a postmortem instead of just an empty window.
+  if (firstPaintTimer) clearTimeout(firstPaintTimer);
+  firstPaintTimer = setTimeout(() => { writeFirstPaintFailureLog(); }, 10_000);
+
   mainWindow.once('ready-to-show', () => {
+    if (firstPaintTimer) { clearTimeout(firstPaintTimer); firstPaintTimer = null; }
     mainWindow.maximize();
     mainWindow.show();
   });
@@ -183,6 +258,7 @@ function createWindow() {
   }
 
   mainWindow.on('closed', () => {
+    if (firstPaintTimer) { clearTimeout(firstPaintTimer); firstPaintTimer = null; }
     mainWindow = null;
   });
 }
@@ -201,6 +277,11 @@ ipcMain.handle('app:is-e2e', () => process.env.SM_E2E === '1');
 
 ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE_RULES || null);
 
+// Boot diagnostics — renderer polls these to surface toasts when `claude` isn't
+// on disk or the home self-check failed (e.g. macOS /Users symlink mismatch).
+ipcMain.handle('app:claude-bin-status', () => bootClaudeBin);
+ipcMain.handle('app:home-self-check', () => bootHomeSelfCheck);
+
 ipcMain.handle('app:pick-directory', async () => {
   console.log('[main] pick-directory invoked');
   const result = await dialog.showOpenDialog(mainWindow, {
@@ -215,6 +296,27 @@ ipcMain.handle('app:pick-directory', async () => {
 
 ipcMain.on('app:reboot-app', () => rebootApp());
 
+// Image paste — Ctrl+V in the Terminal pane. Reads the OS clipboard via
+// Electron's native API (renderer's navigator.clipboard.read() doesn't expose
+// raw image MIME types under contextIsolation), saves the bitmap to a temp
+// PNG, and returns the path. Renderer types the path into the PTY so claude
+// can `@<path>`-reference it.
+ipcMain.handle('clipboard:paste-image', async () => {
+  try {
+    const img = clipboard.readImage();
+    if (!img || img.isEmpty()) return { ok: false, empty: true };
+    const buf = img.toPNG();
+    if (!buf || buf.length === 0) return { ok: false, empty: true };
+    const dir = path.join(os.tmpdir(), 'session-manager-clipboard');
+    await fsp.mkdir(dir, { recursive: true });
+    const file = path.join(dir, `clipboard-${Date.now()}.png`);
+    await fsp.writeFile(file, buf);
+    return { ok: true, path: file, bytes: buf.length };
+  } catch (e) {
+    return { ok: false, error: e && e.message ? e.message : String(e) };
+  }
+});
+
 // Hooks tab "Test fire": run a hook command with a fake event payload piped
 // to stdin. shell:true is intentional — Claude Code's hook field is a shell
 // string. Timeout is enforced via SIGKILL on a timer because spawn's built-in
@@ -550,6 +652,26 @@ app.whenReady().then(async () => {
   logs.pruneOld();
   logs.writeLine({ scope: 'main', level: 'info', message: 'app start', meta: { version: app.getVersion(), platform: process.platform } });
 
+  // Boot-time detection 1: surface `claude` binary resolution so a missing
+  // install becomes visible to the renderer instead of failing silently on
+  // first spawn attempt.
+  const claudeResolved = resolveClaudeBin();
+  const claudeFoundOnDisk = claudeResolved !== 'claude';
+  bootClaudeBin = { resolved: claudeResolved, foundOnDisk: claudeFoundOnDisk };
+  if (claudeFoundOnDisk) {
+    console.log(`[claudeBin] resolved=${claudeResolved}`);
+  } else {
+    console.warn('[claudeBin] FALLBACK no candidate found; spawn will rely on PATH');
+  }
+
+  // Boot-time detection 2: symlinked /Users on macOS can make os.homedir()
+  // realpath to a path outside itself, which breaks every cwd containment
+  // check downstream. Surface here rather than failing on first session spawn.
+  bootHomeSelfCheck = assertCwdInsideHome(os.homedir());
+  if (!bootHomeSelfCheck.ok) {
+    console.error(`[insideHome] SELF-CHECK FAILED: ${bootHomeSelfCheck.error}; sessions will not be able to spawn`);
+  }
+
   process.on('uncaughtException', (err) => {
     logs.writeLine({ scope: 'main', level: 'error', message: 'uncaughtException', meta: { error: err?.message, stack: err?.stack } });
   });

package/src/main/scheduler.cjs

@@ -1385,16 +1385,16 @@ function registerScheduleHandlers() {
     return { ok: true };
   });
 
-  // Archive all pending+failed PRDs and drop their entries from queue.json.
-  // Completed/running entries are kept. PRD files are moved (not deleted) to
-  // prds-archived/<ISO>/ so the user can recover them. Path containment is
-  // enforced — only files inside PRDS_DIR are moved.
+  // Archive every non-running PRD and drop its entry from queue.json.
+  // Running entries are kept (would orphan an in-flight job). PRD files are
+  // moved (not deleted) to prds-archived/<ISO>/ so the user can recover them.
+  // Path containment is enforced — only files inside PRDS_DIR are moved.
   ipcMain.handle('schedule:clear-queue', async () => {
     ensureDirs();
     const ts = new Date().toISOString().replace(/[:.]/g, '-');
     const archiveDir = path.join(PRDS_ARCHIVE_DIR, ts);
     const state = await readQueue();
-    const victims = state.jobs.filter((j) => j.status === 'pending' || j.status === 'failed');
+    const victims = state.jobs.filter((j) => j.status !== 'running');
     if (victims.length === 0) {
       return { ok: true, archived: 0, archivedTo: null };
     }

package/src/main/usage.cjs

@@ -21,6 +21,7 @@ const path = require('node:path');
 const os = require('node:os');
 const { ipcMain } = require('electron');
 const { refreshIfNeeded, expiresAtMs } = require('./lib/credentials.cjs');
+const { writeJson } = require('./config.cjs');
 
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
 const CACHE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'billing-cache.json');
@@ -62,10 +63,7 @@ async function hydrateCache() {
 }
 
 async function persistCache(c) {
-  await fsp.mkdir(path.dirname(CACHE_PATH), { recursive: true });
-  const tmp = `${CACHE_PATH}.${process.pid}.${Date.now()}.tmp`;
-  await fsp.writeFile(tmp, JSON.stringify(c), { encoding: 'utf8', mode: 0o600 });
-  await fsp.rename(tmp, CACHE_PATH);
+  await writeJson(CACHE_PATH, c);
 }
 
 async function fetchUsage() {

package/src/preload/api.d.ts

@@ -531,6 +531,12 @@ export interface SessionManagerAPI {
     testFireHook: (args: TestFireHookArgs) => Promise<TestFireHookResult>;
     /** F7 — true under SM_E2E=1; renderer uses this to suppress wizard auto-trigger. */
     isE2E: () => Promise<boolean>;
+    /** Boot diagnostic — resolved claude binary path + whether it was found
+     *  on disk (false means spawn will rely on PATH and may ENOENT). */
+    claudeBinStatus: () => Promise<{ resolved: string; foundOnDisk: boolean }>;
+    /** Boot diagnostic — assertCwdInsideHome(os.homedir()) result. ok=false
+     *  on macOS symlinked-/Users mismatch and blocks all session spawns. */
+    homeSelfCheck: () => Promise<{ ok: boolean; error?: string; realCwd?: string }>;
     onNewSession: (handler: () => void) => () => void;
     onRebootSession: (handler: () => void) => () => void;
     openInEditor: (cwd: string, editor?: string | null) => Promise<{ ok: boolean; editor?: string; error?: string }>;
@@ -656,6 +662,15 @@ export interface SessionManagerAPI {
     install: (payload: { slug: string }) => Promise<PluginInstallResult>;
     onInstallProgress: (handler: (ev: PluginInstallProgressEvent) => void) => () => void;
   };
+  clipboard: {
+    /** Ctrl+V image paste — reads OS clipboard, saves any image to a temp
+     *  PNG, and returns the absolute path so the renderer can type it into
+     *  the PTY. `ok:false, empty:true` when the clipboard holds no image. */
+    pasteImage: () => Promise<
+      | { ok: true; path: string; bytes: number }
+      | { ok: false; empty?: true; error?: string }
+    >;
+  };
   memory: {
     /** List markdown memory entries for the given workspace (defaults to 'default'). */
     list: (workspace?: string) => Promise<MemoryListResult>;

package/src/preload/index.cjs

@@ -16,6 +16,10 @@ contextBridge.exposeInMainWorld('api', {
     testFireHook: (args) => ipcRenderer.invoke('app:test-fire-hook', args),
     // F7: lets the renderer suppress the wizard auto-trigger under SM_E2E=1.
     isE2E: () => ipcRenderer.invoke('app:is-e2e'),
+    // Boot diagnostics (v0.10.1) — renderer polls at mount to surface
+    // missing-claude-bin / home-symlink-mismatch as toasts.
+    claudeBinStatus: () => ipcRenderer.invoke('app:claude-bin-status'),
+    homeSelfCheck: () => ipcRenderer.invoke('app:home-self-check'),
     onNewSession: (handler) => {
       const listener = () => handler();
       ipcRenderer.on('app:new-session', listener);
@@ -182,6 +186,9 @@ contextBridge.exposeInMainWorld('api', {
       return () => ipcRenderer.removeListener('plugins:install-progress', listener);
     },
   },
+  clipboard: {
+    pasteImage: () => ipcRenderer.invoke('clipboard:paste-image'),
+  },
   memory: {
     list: (workspace) => ipcRenderer.invoke('memory:list', workspace ? { workspace } : {}),
     read: (name, workspace) => ipcRenderer.invoke('memory:read', workspace ? { name, workspace } : { name }),