claude-code-session-manager 0.8.0 → 0.8.2

package/src/main/transcripts.cjs

@@ -84,40 +84,45 @@ function classifyLine(obj) {
 }
 
 /**
- * Read new bytes from the file starting at `offset`, returning {lines, newOffset}.
- * Tolerates partial last lines (keeps them as pending for the next read).
+ * Read new bytes from sub.filePath into sub.offset/pending/inode in place.
+ * Resets offset+pending when the file inode changes (rename+replace rotation).
+ * Returns parsed line strings ready for JSON.parse.
  */
-async function readDelta(filePath, offset, pending) {
-  let stat;
-  try {
-    stat = await fsp.stat(filePath);
-  } catch {
-    return { lines: [], newOffset: offset, pending };
+async function readDelta(sub) {
+  const stat = await fsp.stat(sub.filePath).catch(() => null);
+  if (!stat) return [];
+  // Inode changed → file was replaced underfoot; restart from the top.
+  if (sub.inode !== undefined && stat.ino !== sub.inode) {
+    sub.offset = 0;
+    sub.pending = '';
   }
-  if (stat.size < offset) {
+  if (stat.size < sub.offset) {
     // File was truncated/rotated — start over.
-    offset = 0;
-    pending = '';
+    sub.offset = 0;
+    sub.pending = '';
+  }
+  if (stat.size === sub.offset) {
+    sub.inode = stat.ino;
+    return [];
   }
-  if (stat.size === offset) return { lines: [], newOffset: offset, pending };
-  const fd = await fsp.open(filePath, 'r');
+  const fd = await fsp.open(sub.filePath, 'r');
   try {
-    const length = stat.size - offset;
+    const length = stat.size - sub.offset;
     const buf = Buffer.alloc(length);
-    await fd.read(buf, 0, length, offset);
-    const text = pending + buf.toString('utf8');
+    await fd.read(buf, 0, length, sub.offset);
+    const text = sub.pending + buf.toString('utf8');
     const parts = text.split('\n');
-    const newPending = parts.pop() ?? '';
-    return { lines: parts.filter(Boolean), newOffset: stat.size, pending: newPending };
+    sub.pending = parts.pop() ?? '';
+    sub.offset = stat.size;
+    sub.inode = stat.ino;
+    return parts.filter(Boolean);
   } finally {
     await fd.close();
   }
 }
 
 async function flush(sub, { emit = true } = {}) {
-  const { lines, newOffset, pending } = await readDelta(sub.filePath, sub.offset, sub.pending);
-  sub.offset = newOffset;
-  sub.pending = pending;
+  const lines = await readDelta(sub);
   for (const line of lines) {
     let obj;
     try {

package/src/main/usage.cjs

@@ -20,48 +20,99 @@ const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
 const { ipcMain } = require('electron');
+const { refreshIfNeeded, expiresAtMs } = require('./lib/credentials.cjs');
 
-const CREDS_PATH = path.join(os.homedir(), '.claude', '.credentials.json');
 const USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
+const CACHE_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'billing-cache.json');
 
-async function readCredentials() {
-  const raw = await fsp.readFile(CREDS_PATH, 'utf8');
-  const data = JSON.parse(raw);
-  const oa = data?.claudeAiOauth;
-  if (!oa?.accessToken) throw new Error('not signed in (missing accessToken)');
-  return oa;
+let cache = null;
+let hydrationPromise = null;
+
+async function hydrateCache() {
+  try {
+    cache = JSON.parse(await fsp.readFile(CACHE_PATH, 'utf8'));
+  } catch {
+    cache = null;
+  }
+}
+
+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);
 }
 
 async function fetchUsage() {
-  const creds = await readCredentials();
-  const r = await fetch(USAGE_URL, {
-    headers: {
-      Authorization: `Bearer ${creds.accessToken}`,
-      'anthropic-beta': 'oauth-2025-04-20',
-      'User-Agent': 'claude-code-session-manager',
-    },
-  });
+  // Check expiry and attempt proactive refresh before touching the network.
+  const refresh = await refreshIfNeeded();
+  if (refresh.kind === 'auth') {
+    return { kind: 'auth', message: refresh.message, httpStatus: 401, expiredAt: refresh.expiredAt ?? null };
+  }
+  if (refresh.kind === 'config') return refresh;
+  // 'ok' or 'unsupported' — creds present and not yet expired
+  const creds = refresh.creds;
+
+  let r;
+  try {
+    r = await fetch(USAGE_URL, {
+      headers: {
+        Authorization: `Bearer ${creds.accessToken}`,
+        'anthropic-beta': 'oauth-2025-04-20',
+        'User-Agent': 'claude-code-session-manager',
+      },
+      signal: AbortSignal.timeout(10_000),
+    });
+  } catch (e) {
+    return { kind: 'transient', message: e.message || String(e), httpStatus: null };
+  }
+  if (r.status === 401 || r.status === 403) {
+    const body = await r.text().catch(() => '');
+    const ms = expiresAtMs(creds);
+    return { kind: 'auth', message: body.slice(0, 200) || `HTTP ${r.status}`, httpStatus: r.status, expiredAt: ms };
+  }
+  if (r.status === 408 || r.status === 429 || r.status >= 500) {
+    const body = await r.text().catch(() => '');
+    return { kind: 'transient', message: body.slice(0, 200) || `HTTP ${r.status}`, httpStatus: r.status };
+  }
   if (!r.ok) {
     const body = await r.text().catch(() => '');
-    throw new Error(`usage HTTP ${r.status}: ${body.slice(0, 200)}`);
+    return { kind: 'transient', message: body.slice(0, 200) || `HTTP ${r.status}`, httpStatus: r.status };
   }
   const usage = await r.json();
   return {
-    usage,
-    subscriptionType: creds.subscriptionType ?? null,
-    rateLimitTier: creds.rateLimitTier ?? null,
-    credentialsExpiresAt: creds.expiresAt ?? null,
-    fetchedAt: Date.now(),
+    kind: 'ok',
+    data: {
+      usage,
+      subscriptionType: creds.subscriptionType ?? null,
+      rateLimitTier: creds.rateLimitTier ?? null,
+      credentialsExpiresAt: creds.expiresAt ?? null,
+      fetchedAt: Date.now(),
+    },
   };
 }
 
 function registerBillingHandlers() {
+  hydrationPromise = hydrateCache();
+
   ipcMain.handle('billing:fetch', async () => {
-    try {
-      return { ok: true, data: await fetchUsage() };
-    } catch (e) {
-      return { ok: false, error: e?.message ?? String(e) };
+    if (hydrationPromise) { await hydrationPromise; hydrationPromise = null; }
+
+    const r = await fetchUsage();
+    if (r.kind === 'ok') {
+      cache = { data: r.data, fetchedAt: Date.now(), sourceCredsExpiresAt: r.data.credentialsExpiresAt };
+      persistCache(cache).catch(() => {});
+      return { kind: 'ok', data: r.data };
+    }
+    if (r.kind === 'auth') {
+      if (cache) return { kind: 'auth', message: r.message, httpStatus: r.httpStatus, expiredAt: r.expiredAt, cached: cache.data, staleSince: cache.fetchedAt };
+      return r;
+    }
+    if (r.kind === 'transient') {
+      if (cache) return { kind: 'ok-stale', data: cache.data, staleSince: cache.fetchedAt, lastError: r.message };
+      return r;
     }
+    return r; // config
   });
 }
 

package/src/main/voiceSettings.cjs

@@ -109,7 +109,7 @@ async function writeMerged(patch) {
     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, 'utf8', { mode: 0o600 });
+    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 { /* */ }

package/src/main/watchers.cjs

@@ -10,8 +10,40 @@
 
 const { ipcMain } = require('electron');
 const { spawn } = require('node:child_process');
-const readline = require('node:readline');
 const crypto = require('node:crypto');
+const path = require('node:path');
+const os = require('node:os');
+const fs = require('node:fs');
+const { cleanChildEnv } = require('./lib/cleanEnv.cjs');
+
+// Splits a readable stream into lines capped at maxLineBytes. Prevents OOM
+// from commands that produce no newlines (e.g. cat /dev/urandom | base64).
+function lineSplit(stream, onLine, maxLineBytes = 4096) {
+  let buf = Buffer.alloc(0);
+  stream.on('data', (chunk) => {
+    buf = Buffer.concat([buf, chunk]);
+    while (true) {
+      const nl = buf.indexOf(0x0a);
+      if (nl === -1) {
+        if (buf.length > maxLineBytes) {
+          onLine(buf.slice(0, maxLineBytes).toString('utf8') + '…[truncated]');
+          buf = Buffer.alloc(0);
+        }
+        return;
+      }
+      const line = buf.slice(0, nl).toString('utf8');
+      buf = buf.slice(nl + 1);
+      onLine(line.length > maxLineBytes ? line.slice(0, maxLineBytes) + '…[truncated]' : line);
+    }
+  });
+  stream.on('end', () => {
+    if (buf.length > 0) {
+      onLine(buf.length > maxLineBytes
+        ? buf.slice(0, maxLineBytes).toString('utf8') + '…[truncated]'
+        : buf.toString('utf8'));
+    }
+  });
+}
 
 class WatcherManager {
   constructor() {
@@ -25,13 +57,27 @@ 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 watcherId = crypto.randomUUID();
     const trimmedLabel = (label && label.trim()) || command.slice(0, 40);
     const child = spawn(command, [], {
-      cwd: cwd || process.cwd(),
+      cwd: resolvedCwd,
       shell: true,
       stdio: ['ignore', 'pipe', 'pipe'],
-      env: process.env,
+      env: cleanChildEnv(),
     });
 
     const entry = {
@@ -39,7 +85,7 @@ class WatcherManager {
       tabId,
       label: trimmedLabel,
       command,
-      cwd: cwd || process.cwd(),
+      cwd: resolvedCwd,
       child,
       startedAt: Date.now(),
       lineCount: 0,
@@ -59,18 +105,16 @@ class WatcherManager {
       }
     };
 
-    const stdoutRl = readline.createInterface({ input: child.stdout });
-    stdoutRl.on('line', emitLine);
-    const stderrRl = readline.createInterface({ input: child.stderr });
-    stderrRl.on('line', emitLine);
+    lineSplit(child.stdout, emitLine);
+    lineSplit(child.stderr, emitLine);
 
     child.on('error', (err) => {
       emitLine(`[watcher error] ${err?.message ?? String(err)}`);
+      // Remove from map so list() doesn't return ghosts after a spawn failure.
+      this.watchers.delete(watcherId);
     });
 
     child.on('close', (code, signal) => {
-      stdoutRl.close();
-      stderrRl.close();
       // Only emit close if still registered (remove() suppresses by deleting first).
       if (this.watchers.has(watcherId)) {
         emitLine(`[exited code=${code ?? 'null'}${signal ? ` signal=${signal}` : ''}]`);
@@ -135,6 +179,12 @@ class WatcherManager {
 
 const manager = new WatcherManager();
 
+// Top-level export so index.cjs can call watchers.attachWindow(mainWindow)
+// without going through the manager instance directly.
+function attachWindow(window) {
+  manager.attachWindow(window);
+}
+
 function registerWatcherHandlers() {
   const { z } = require('zod');
   const addSchema = z.object({
@@ -145,10 +195,18 @@ function registerWatcherHandlers() {
   });
   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);
+    for (const [id, w] of manager.watchers) {
+      if (w.tabId === tabId) manager.remove({ watcherId: id });
+    }
+    return { ok: true };
+  });
 }
 
-module.exports = { manager, registerWatcherHandlers };
+module.exports = { manager, attachWindow, registerWatcherHandlers };

package/src/preload/api.d.ts

@@ -10,6 +10,11 @@ export interface PtyExit {
   signal?: number;
 }
 
+export interface WriteErrorEvent {
+  tabId: string;
+  reason: string;
+}
+
 export interface ReadJsonResult {
   exists: boolean;
   raw: string;
@@ -84,6 +89,8 @@ export interface PersistedTab {
 export interface LoadedSessions {
   tabs: PersistedTab[];
   activeTabId: string | null;
+  /** True when the main process rotated all session IDs on boot (e.g. force-fresh). */
+  freshStart?: boolean;
 }
 
 export interface UsageWindow {
@@ -107,18 +114,21 @@ export interface UsageSnapshot {
   [key: string]: unknown;
 }
 
-export interface BillingFetchResult {
-  ok: boolean;
-  data?: {
-    usage: UsageSnapshot;
-    subscriptionType: string | null;
-    rateLimitTier: string | null;
-    credentialsExpiresAt: number | null;
-    fetchedAt: number;
-  };
-  error?: string;
+export interface BillingData {
+  usage: UsageSnapshot;
+  subscriptionType: string | null;
+  rateLimitTier: string | null;
+  credentialsExpiresAt: string | null;
+  fetchedAt: number;
 }
 
+export type BillingFetchResult =
+  | { kind: 'ok'; data: BillingData }
+  | { kind: 'ok-stale'; data: BillingData; staleSince: number; lastError: string }
+  | { kind: 'auth'; message: string; httpStatus: number; expiredAt?: number | null; cached?: BillingData; staleSince?: number }
+  | { kind: 'transient'; message: string; httpStatus: number | null }
+  | { kind: 'config'; message: string };
+
 export interface VoiceHotkeyConfig {
   accelerator: string;
   mode: 'hold' | 'toggle';
@@ -259,7 +269,7 @@ export interface SchedulePaths {
   queue: string;
 }
 
-export type SchedulePauseReason = 'rate_limit';
+export type SchedulePauseReason = 'rate_limit' | 'auth' | 'network' | 'manual' | 'reset_failure';
 
 export interface SchedulePauseInfo {
   reason: SchedulePauseReason;
@@ -270,6 +280,27 @@ export interface SchedulePauseInfo {
   resumeAt: string | null;
 }
 
+export interface ScheduleHealthSnapshot {
+  bootedAt: number;
+  lastPollAt: number | null;
+  lastPollOk: boolean;
+  consecutiveFailures: number;
+  backoffNextAt: number | null;
+  nextResetCached: string | null;
+  pausedSince: number | null;
+  pauseReason: SchedulePauseReason | null;
+  runningJobs: { slug: string; startedAt: number; pid: number }[];
+}
+
+export interface PrdListItem {
+  slug: string;
+  parallelGroup: number;
+  title: string;
+  cwd: string;
+  estimateMinutes: number | null;
+  mtimeMs: number;
+}
+
 export interface ScheduleStateSnapshot {
   config: ScheduleConfig;
   jobs: ScheduleJob[];
@@ -331,6 +362,10 @@ export interface SessionManagerAPI {
     isE2E: () => Promise<boolean>;
     onNewSession: (handler: () => void) => () => void;
     onRebootSession: (handler: () => void) => () => void;
+    openInEditor: (cwd: string, editor?: string | null) => Promise<{ ok: boolean; editor?: string; error?: string }>;
+    openInFinder: (cwd: string) => Promise<{ ok: boolean; error?: string }>;
+    openInTerminal: (cwd: string) => Promise<{ ok: boolean; terminal?: string; error?: string }>;
+    archiveProject: (encoded: string) => Promise<{ ok: boolean; error?: string }>;
   };
   pty: {
     spawn: (payload: { tabId: string; cwd: string; cols?: number; rows?: number }) => Promise<SpawnResult>;
@@ -339,6 +374,7 @@ export interface SessionManagerAPI {
     kill: (tabId: string) => void;
     onData: (tabId: string, handler: (data: string) => void) => () => void;
     onExit: (tabId: string, handler: (info: PtyExit) => void) => () => void;
+    onWriteError: (handler: (ev: WriteErrorEvent) => void) => () => void;
   };
   transcripts: {
     subscribe: (payload: { tabId: string; cwd: string; sessionUuid: string }) => Promise<SubscribeResult>;
@@ -393,6 +429,7 @@ export interface SessionManagerAPI {
     add: (payload: { tabId: string; label?: string; command: string; cwd?: string | null }) => Promise<WatcherAddResult>;
     list: (tabId: string) => Promise<WatcherInfo[]>;
     remove: (watcherId: string) => Promise<{ ok: boolean }>;
+    killTab: (tabId: string) => Promise<{ ok: boolean }>;
     onLine: (handler: (ev: WatcherLineEvent) => void) => () => void;
     onClosed: (handler: (ev: WatcherClosedEvent) => void) => () => void;
   };
@@ -412,6 +449,9 @@ export interface SessionManagerAPI {
     openFolder: () => Promise<{ ok: boolean }>;
     readPrd: (slug: string) => Promise<{ ok: boolean; text?: string; error?: string }>;
     readLog: (runId: string, slug: string) => Promise<{ ok: boolean; text?: string; error?: string }>;
+    writePrd: (slug: string, body: string) => Promise<{ ok: boolean; bytesWritten: number }>;
+    listPrds: () => Promise<PrdListItem[]>;
+    health: () => Promise<ScheduleHealthSnapshot>;
     onState: (handler: (snapshot: ScheduleStateSnapshot) => void) => () => void;
   };
 }
@@ -420,6 +460,8 @@ declare global {
   interface Window {
     api: SessionManagerAPI;
   }
+  // Injected by Vite's `define` from package.json at build time.
+  const __APP_VERSION__: string;
 }
 
 export {};

package/src/preload/index.cjs

@@ -9,6 +9,10 @@ contextBridge.exposeInMainWorld('api', {
     pickDirectory: () => ipcRenderer.invoke('app:pick-directory'),
     gitBranch: (cwd) => ipcRenderer.invoke('app:git-branch', { cwd }),
     rebootApp: () => ipcRenderer.send('app:reboot-app'),
+    openInEditor: (cwd, editor) => ipcRenderer.invoke('app:open-in-editor', { cwd, editor }),
+    openInFinder: (cwd) => ipcRenderer.invoke('app:open-in-finder', { cwd }),
+    openInTerminal: (cwd) => ipcRenderer.invoke('app:open-in-terminal', { cwd }),
+    archiveProject: (encoded) => ipcRenderer.invoke('app:archive-project', { encoded }),
     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'),
@@ -40,6 +44,11 @@ contextBridge.exposeInMainWorld('api', {
       ipcRenderer.on(channel, listener);
       return () => ipcRenderer.removeListener(channel, listener);
     },
+    onWriteError: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('pty:write-error', listener);
+      return () => ipcRenderer.removeListener('pty:write-error', listener);
+    },
   },
   transcripts: {
     subscribe: (payload) => ipcRenderer.invoke('transcript:subscribe', payload),
@@ -111,6 +120,7 @@ contextBridge.exposeInMainWorld('api', {
     add: (payload) => ipcRenderer.invoke('watchers:add', payload),
     list: (tabId) => ipcRenderer.invoke('watchers:list', { tabId }),
     remove: (watcherId) => ipcRenderer.invoke('watchers:remove', { watcherId }),
+    killTab: (tabId) => ipcRenderer.invoke('watchers:kill-tab', { tabId }),
     onLine: (handler) => {
       const listener = (_e, payload) => handler(payload);
       ipcRenderer.on('watcher:line', listener);
@@ -138,6 +148,9 @@ contextBridge.exposeInMainWorld('api', {
     openFolder: () => ipcRenderer.invoke('schedule:open-folder'),
     readPrd: (slug) => ipcRenderer.invoke('schedule:read-prd', { slug }),
     readLog: (runId, slug) => ipcRenderer.invoke('schedule:read-log', { runId, slug }),
+    writePrd: (slug, body) => ipcRenderer.invoke('schedule:write-prd', { slug, body }),
+    listPrds: () => ipcRenderer.invoke('schedule:list-prds'),
+    health: () => ipcRenderer.invoke('schedule:health'),
     onState: (handler) => {
       const listener = (_e, payload) => handler(payload);
       ipcRenderer.on('schedule:state', listener);