claude-code-session-manager 0.1.0

package/src/main/sessionsStore.cjs

@@ -0,0 +1,70 @@
+/**
+ * SessionsStore — persists the renderer's tab list to disk so the app can
+ * restore tabs + resume claude sessions after an electron restart.
+ *
+ * Storage: ~/.config/session-manager/tabs.json
+ * Shape: { tabs: PersistedTab[], activeTabId: string | null, savedAt: number }
+ *
+ * Only serializable, durable fields are persisted: id, claudeSessionId, cwd,
+ * label, presetId. Runtime-only fields (pid, status, startupCommand,
+ * exitCode) are recomputed on boot.
+ */
+
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const { ipcMain } = require('electron');
+
+function storePath() {
+  return path.join(os.homedir(), '.config', 'session-manager', 'tabs.json');
+}
+
+async function load() {
+  const p = storePath();
+  try {
+    const raw = await fsp.readFile(p, 'utf8');
+    const data = JSON.parse(raw);
+    if (!data || !Array.isArray(data.tabs)) return { tabs: [], activeTabId: null, freshStart: false };
+    return {
+      tabs: data.tabs,
+      activeTabId: typeof data.activeTabId === 'string' ? data.activeTabId : null,
+      freshStart: !!data.freshStart,
+    };
+  } catch (e) {
+    if (e.code !== 'ENOENT') console.warn('[sessionsStore] load failed:', e.message);
+    return { tabs: [], activeTabId: null, freshStart: false };
+  }
+}
+
+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);
+  return { ok: true };
+}
+
+function registerSessionsHandlers() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('sessions:load', () => load());
+  ipcMain.handle('sessions:save', v(s.sessionsPayload, (payload) => save(payload)));
+}
+
+/** Rewrite persisted tabs with fresh session IDs so next boot starts new sessions. */
+async function markFreshRestart() {
+  const { tabs, activeTabId } = await load();
+  if (tabs.length === 0) return;
+  const crypto = require('node:crypto');
+  const freshTabs = tabs.map((t) => ({
+    ...t,
+    claudeSessionId: crypto.randomUUID(),
+  }));
+  await save({ tabs: freshTabs, activeTabId, freshStart: true });
+}
+
+module.exports = { registerSessionsHandlers, load, save, storePath, markFreshRestart };

package/src/main/transcripts.cjs

@@ -0,0 +1,212 @@
+/**
+ * TranscriptsManager — tails Claude Code session JSONL files and emits
+ * structured events to the renderer.
+ *
+ * Transcript path convention (Apr 2026):
+ *   ~/.claude/projects/<encoded-cwd>/<session-uuid>.jsonl
+ *
+ * cwd encoding: every non-alphanumeric char → '-' (literal regex
+ * /[^a-zA-Z0-9]/g → '-').
+ *
+ * Deterministic mapping: renderer passes `--session-id <tab-uuid>` when
+ * launching `claude`. This manager expects that same UUID as the file's
+ * basename. Consumers subscribe per (tabId, cwd, sessionUuid) triple.
+ *
+ * Each subscription opens a single chokidar watcher on the directory and
+ * streams new bytes from the matching file, splits on newlines, zod-passes
+ * each line through a lax schema, then forwards typed events.
+ */
+
+const { ipcMain } = require('electron');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const chokidar = require('chokidar');
+
+let window = null;
+
+/** Map<tabId, Subscription> */
+const subs = new Map();
+
+function attachWindow(w) {
+  window = w;
+}
+
+function encodeCwd(cwd) {
+  return cwd.replace(/[^a-zA-Z0-9]/g, '-');
+}
+
+function transcriptPath(cwd, sessionUuid) {
+  return path.join(os.homedir(), '.claude', 'projects', encodeCwd(cwd), `${sessionUuid}.jsonl`);
+}
+
+/**
+ * Parse one JSONL line defensively. Real schema drifts, so we pass through
+ * anything that parses and tag a coarse `kind`.
+ */
+function classifyLine(obj) {
+  if (!obj || typeof obj !== 'object') return null;
+  // Many shapes exist — try several common fields.
+  const type = obj.type || obj.event || obj.role;
+  const msg = obj.message || obj;
+  const content = msg?.content;
+
+  // Usage rollups arrive as summary events.
+  if (obj.usage || msg?.usage) {
+    return { kind: 'usage', data: obj.usage || msg.usage, raw: obj };
+  }
+
+  // Tool uses: scan content array for tool_use blocks.
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      if (block?.type === 'tool_use') {
+        if (block.name === 'TodoWrite') {
+          return { kind: 'todo_write', data: block.input?.todos || block.input || [], raw: obj };
+        }
+        if (block.name === 'ExitPlanMode' || block.name === 'EnterPlanMode') {
+          return { kind: 'plan', data: block.input, raw: obj };
+        }
+        if (block.name === 'Agent' || block.name === 'Task') {
+          return { kind: 'agent_spawn', data: block.input, raw: obj };
+        }
+        return {
+          kind: 'tool_use',
+          data: { name: block.name, input: block.input, id: block.id },
+          raw: obj,
+        };
+      }
+    }
+  }
+
+  return { kind: type || 'message', data: obj, raw: 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).
+ */
+async function readDelta(filePath, offset, pending) {
+  let stat;
+  try {
+    stat = await fsp.stat(filePath);
+  } catch {
+    return { lines: [], newOffset: offset, pending };
+  }
+  if (stat.size < offset) {
+    // File was truncated/rotated — start over.
+    offset = 0;
+    pending = '';
+  }
+  if (stat.size === offset) return { lines: [], newOffset: offset, pending };
+  const fd = await fsp.open(filePath, 'r');
+  try {
+    const length = stat.size - offset;
+    const buf = Buffer.alloc(length);
+    await fd.read(buf, 0, length, offset);
+    const text = pending + buf.toString('utf8');
+    const parts = text.split('\n');
+    const newPending = parts.pop() ?? '';
+    return { lines: parts.filter(Boolean), newOffset: stat.size, pending: newPending };
+  } 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;
+  for (const line of lines) {
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const ev = classifyLine(obj);
+    if (!ev) continue;
+    // 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);
+    }
+  }
+}
+
+const MAX_TRANSCRIPT_SUBS = 20;
+
+async function subscribe({ tabId, cwd, sessionUuid }) {
+  if (subs.has(tabId)) return { ok: true, path: subs.get(tabId).filePath };
+  if (subs.size >= MAX_TRANSCRIPT_SUBS) {
+    return { ok: false, path: null, error: 'too many active subscriptions' };
+  }
+  const filePath = transcriptPath(cwd, sessionUuid);
+  const dir = path.dirname(filePath);
+  await fsp.mkdir(dir, { recursive: true }).catch(() => {});
+  const sub = {
+    tabId,
+    cwd,
+    sessionUuid,
+    filePath,
+    offset: 0,
+    pending: '',
+    buffer: [],
+    watcher: null,
+  };
+  // If the file already exists, read current content as replay. Do not emit
+  // during this initial drain — the renderer drains sub.buffer via
+  // `transcript:buffer` after `transcript:subscribe` resolves. Emitting here
+  // would race the renderer's onEvent listener registration and drop events.
+  if (fs.existsSync(filePath)) {
+    await flush(sub, { emit: false });
+  }
+  const watcher = chokidar.watch(filePath, {
+    ignoreInitial: false,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 30, pollInterval: 20 },
+  });
+  watcher.on('add', () => flush(sub).catch(() => {}));
+  watcher.on('change', () => flush(sub).catch(() => {}));
+  watcher.on('error', (err) => console.warn('[transcripts] watcher error:', err.message));
+  sub.watcher = watcher;
+  subs.set(tabId, sub);
+  return { ok: true, path: filePath };
+}
+
+function unsubscribe(tabId) {
+  const sub = subs.get(tabId);
+  if (!sub) return;
+  sub.watcher?.close().catch(() => {});
+  subs.delete(tabId);
+}
+
+function getBuffer(tabId) {
+  const sub = subs.get(tabId);
+  return sub ? sub.buffer.slice() : [];
+}
+
+function closeAll() {
+  for (const sub of subs.values()) sub.watcher?.close().catch(() => {});
+  subs.clear();
+}
+
+function registerTranscriptHandlers() {
+  const { schemas: s, validated: v } = require('./ipcSchemas.cjs');
+  ipcMain.handle('transcript:subscribe', v(s.transcriptSubscribe, (payload) => subscribe(payload)));
+  ipcMain.handle('transcript:unsubscribe', v(s.transcriptTabId, ({ tabId }) => {
+    unsubscribe(tabId);
+    return { ok: true };
+  }));
+  ipcMain.handle('transcript:buffer', v(s.transcriptTabId, ({ tabId }) => getBuffer(tabId)));
+  ipcMain.handle('transcript:path', v(s.transcriptPath, ({ cwd, sessionUuid }) => transcriptPath(cwd, sessionUuid)));
+}
+
+module.exports = {
+  attachWindow,
+  registerTranscriptHandlers,
+  closeAll,
+  encodeCwd,
+  transcriptPath,
+};

package/src/preload/api.d.ts

@@ -0,0 +1,138 @@
+export interface SpawnResult {
+  pid: number;
+  cwd: string;
+  /** True when spawn() found an existing PTY for this tabId and reattached. */
+  reattached: boolean;
+}
+
+export interface PtyExit {
+  exitCode: number;
+  signal?: number;
+}
+
+export interface ReadJsonResult {
+  exists: boolean;
+  raw: string;
+  data: unknown;
+  parseError: string | null;
+  mtimeMs: number;
+  error: string | null;
+}
+
+export interface ReadTextResult {
+  exists: boolean;
+  text: string;
+  mtimeMs: number;
+  error: string | null;
+}
+
+export interface WriteResult {
+  ok: boolean;
+  mtimeMs: number;
+  error?: string;
+}
+
+export interface DirEntry {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  isFile: boolean;
+  mtimeMs: number;
+  size: number;
+}
+
+export interface ListDirResult {
+  ok: boolean;
+  entries: DirEntry[];
+  error: string | null;
+}
+
+export interface ConfigChangedEvent {
+  path: string;
+  mtimeMs: number;
+  kind: 'add' | 'change' | 'unlink';
+}
+
+export type TranscriptEventKind =
+  | 'tool_use'
+  | 'todo_write'
+  | 'plan'
+  | 'usage'
+  | 'agent_spawn'
+  | 'message'
+  | string;
+
+export interface TranscriptEvent {
+  kind: TranscriptEventKind;
+  data: unknown;
+  raw: unknown;
+}
+
+export interface SubscribeResult {
+  ok: boolean;
+  path: string;
+}
+
+export interface PersistedTab {
+  id: string;
+  claudeSessionId: string;
+  cwd: string;
+  label: string;
+  presetId: string | null;
+}
+
+export interface LoadedSessions {
+  tabs: PersistedTab[];
+  activeTabId: string | null;
+}
+
+export interface SessionManagerAPI {
+  app: {
+    version: () => Promise<string>;
+    homeDir: () => Promise<string>;
+    cwd: () => Promise<string>;
+    engageRulesPath: () => Promise<string | null>;
+    pickDirectory: () => Promise<string | null>;
+    rebootApp: () => void;
+    onNewSession: (handler: () => void) => () => void;
+    onRebootSession: (handler: () => void) => () => void;
+  };
+  pty: {
+    spawn: (payload: { tabId: string; cwd: string; cols?: number; rows?: number }) => Promise<SpawnResult>;
+    write: (payload: { tabId: string; data: string }) => void;
+    resize: (payload: { tabId: string; cols: number; rows: number }) => void;
+    kill: (tabId: string) => void;
+    onData: (tabId: string, handler: (data: string) => void) => () => void;
+    onExit: (tabId: string, handler: (info: PtyExit) => void) => () => void;
+  };
+  transcripts: {
+    subscribe: (payload: { tabId: string; cwd: string; sessionUuid: string }) => Promise<SubscribeResult>;
+    unsubscribe: (tabId: string) => Promise<{ ok: boolean }>;
+    buffer: (tabId: string) => Promise<TranscriptEvent[]>;
+    pathFor: (cwd: string, sessionUuid: string) => Promise<string>;
+    onEvent: (tabId: string, handler: (ev: TranscriptEvent) => void) => () => void;
+  };
+  sessions: {
+    load: () => Promise<LoadedSessions>;
+    save: (payload: LoadedSessions) => Promise<{ ok: boolean }>;
+  };
+  config: {
+    readJson: (path: string) => Promise<ReadJsonResult>;
+    readText: (path: string) => Promise<ReadTextResult>;
+    writeJson: (path: string, data: unknown) => Promise<WriteResult>;
+    writeText: (path: string, text: string) => Promise<WriteResult>;
+    listDir: (path: string, opts?: { filesOnly?: boolean; dirsOnly?: boolean; includeHidden?: boolean }) => Promise<ListDirResult>;
+    exists: (path: string) => Promise<boolean>;
+    watch: (paths: string[]) => void;
+    unwatch: (paths: string[]) => void;
+    onChanged: (handler: (info: ConfigChangedEvent) => void) => () => void;
+  };
+}
+
+declare global {
+  interface Window {
+    api: SessionManagerAPI;
+  }
+}
+
+export {};

package/src/preload/index.cjs

@@ -0,0 +1,72 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('api', {
+  app: {
+    version: () => ipcRenderer.invoke('app:version'),
+    homeDir: () => ipcRenderer.invoke('app:home-dir'),
+    cwd: () => ipcRenderer.invoke('app:cwd'),
+    engageRulesPath: () => ipcRenderer.invoke('app:engage-rules-path'),
+    pickDirectory: () => ipcRenderer.invoke('app:pick-directory'),
+    rebootApp: () => ipcRenderer.send('app:reboot-app'),
+    onNewSession: (handler) => {
+      const listener = () => handler();
+      ipcRenderer.on('app:new-session', listener);
+      return () => ipcRenderer.removeListener('app:new-session', listener);
+    },
+    onRebootSession: (handler) => {
+      const listener = () => handler();
+      ipcRenderer.on('app:reboot-session', listener);
+      return () => ipcRenderer.removeListener('app:reboot-session', listener);
+    },
+  },
+  pty: {
+    spawn: (payload) => ipcRenderer.invoke('pty:spawn', payload),
+    write: (payload) => ipcRenderer.send('pty:write', payload),
+    resize: (payload) => ipcRenderer.send('pty:resize', payload),
+    kill: (tabId) => ipcRenderer.send('pty:kill', tabId),
+    onData: (tabId, handler) => {
+      const channel = `pty:data:${tabId}`;
+      const listener = (_e, data) => handler(data);
+      ipcRenderer.on(channel, listener);
+      return () => ipcRenderer.removeListener(channel, listener);
+    },
+    onExit: (tabId, handler) => {
+      const channel = `pty:exit:${tabId}`;
+      const listener = (_e, info) => handler(info);
+      ipcRenderer.on(channel, listener);
+      return () => ipcRenderer.removeListener(channel, listener);
+    },
+  },
+  transcripts: {
+    subscribe: (payload) => ipcRenderer.invoke('transcript:subscribe', payload),
+    unsubscribe: (tabId) => ipcRenderer.invoke('transcript:unsubscribe', { tabId }),
+    buffer: (tabId) => ipcRenderer.invoke('transcript:buffer', { tabId }),
+    pathFor: (cwd, sessionUuid) =>
+      ipcRenderer.invoke('transcript:path', { cwd, sessionUuid }),
+    onEvent: (tabId, handler) => {
+      const channel = `transcript:event:${tabId}`;
+      const listener = (_e, ev) => handler(ev);
+      ipcRenderer.on(channel, listener);
+      return () => ipcRenderer.removeListener(channel, listener);
+    },
+  },
+  sessions: {
+    load: () => ipcRenderer.invoke('sessions:load'),
+    save: (payload) => ipcRenderer.invoke('sessions:save', payload),
+  },
+  config: {
+    readJson: (path) => ipcRenderer.invoke('config:read-json', { path }),
+    readText: (path) => ipcRenderer.invoke('config:read-text', { path }),
+    writeJson: (path, data) => ipcRenderer.invoke('config:write-json', { path, data }),
+    writeText: (path, text) => ipcRenderer.invoke('config:write-text', { path, text }),
+    listDir: (path, opts) => ipcRenderer.invoke('config:list-dir', { path, opts }),
+    exists: (path) => ipcRenderer.invoke('config:exists', { path }),
+    watch: (paths) => ipcRenderer.send('config:watch', { paths }),
+    unwatch: (paths) => ipcRenderer.send('config:unwatch', { paths }),
+    onChanged: (handler) => {
+      const listener = (_e, info) => handler(info);
+      ipcRenderer.on('config:changed', listener);
+      return () => ipcRenderer.removeListener('config:changed', listener);
+    },
+  },
+});