claude-code-session-manager 0.10.5 → 0.11.0

package/src/main/historyAggregator.cjs

@@ -105,6 +105,34 @@ async function parseJSONL(filePath, stat) {
   return acc;
 }
 
+/** Lightweight per-file meta: { firstTs, lastTs, inputTokens, outputTokens, skipped }.
+ *  Powers the `history:list-conversations` IPC used by the Overview detailed-
+ *  stats panel. Single-pass O(L) scan, only honors ts + usage blocks. */
+async function parseConversationMeta(filePath, stat) {
+  const meta = { firstTs: null, lastTs: null, inputTokens: 0, outputTokens: 0, skipped: false };
+  if (stat.size > MAX_FILE_BYTES) { meta.skipped = true; return meta; }
+  let text;
+  try { text = await fsp.readFile(filePath, 'utf8'); } catch { return meta; }
+  const lines = text.split('\n');
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (!line) continue;
+    let obj;
+    try { obj = JSON.parse(line); } catch { continue; }
+    const ts = obj.ts ?? obj.timestamp;
+    if (ts) {
+      if (meta.firstTs === null) meta.firstTs = ts;
+      meta.lastTs = ts;
+    }
+    const usage = obj.usage ?? obj.message?.usage;
+    if (usage && typeof usage === 'object') {
+      if (typeof usage.inputTokens === 'number') meta.inputTokens += usage.inputTokens;
+      if (typeof usage.outputTokens === 'number') meta.outputTokens += usage.outputTokens;
+    }
+  }
+  return meta;
+}
+
 function registerHistoryAggregatorHandlers() {
   ipcMain.handle('history:aggregate', async (_e, rawReq) => {
     // Wire the historyAggregate schema (previously defined but never used).
@@ -208,6 +236,48 @@ function registerHistoryAggregatorHandlers() {
     const scannedMs = Date.now() - t0;
     return { rows, partial, scannedMs, skippedLargeFiles };
   });
+
+  /** Per-conversation metadata: one row per JSONL with derived duration +
+   *  token totals. Used by the Overview detailed-stats panel to compute
+   *  hourly/daily distribution + top-projects. */
+  ipcMain.handle('history:list-conversations', async () => {
+    const t0 = Date.now();
+    const conversations = [];
+    let projectEntries;
+    try {
+      projectEntries = await fsp.readdir(PROJECTS_DIR, { withFileTypes: true });
+    } catch {
+      return { conversations: [], scannedMs: Date.now() - t0 };
+    }
+    for (const ent of projectEntries) {
+      if (!ent.isDirectory()) continue;
+      const projectDir = path.join(PROJECTS_DIR, ent.name);
+      const projectFolder = '/' + ent.name.replace(/-/g, '/');
+      let files;
+      try { files = await fsp.readdir(projectDir, { withFileTypes: true }); } catch { continue; }
+      for (const f of files) {
+        if (!f.isFile() || !f.name.endsWith('.jsonl')) continue;
+        const filePath = path.join(projectDir, f.name);
+        let stat;
+        try { stat = await fsp.stat(filePath); } catch { continue; }
+        const meta = await parseConversationMeta(filePath, stat);
+        const firstTs = meta.firstTs || new Date(stat.mtimeMs).toISOString();
+        const duration =
+          meta.firstTs && meta.lastTs
+            ? Math.max(0, Date.parse(meta.lastTs) - Date.parse(meta.firstTs))
+            : undefined;
+        conversations.push({
+          timestamp: firstTs,
+          projectFolder,
+          stats: {
+            ...(duration !== undefined ? { duration } : {}),
+            estimatedTokens: meta.inputTokens + meta.outputTokens,
+          },
+        });
+      }
+    }
+    return { conversations, scannedMs: Date.now() - t0 };
+  });
 }
 
 module.exports = { registerHistoryAggregatorHandlers };

package/src/main/index.cjs

@@ -24,7 +24,12 @@ const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
 const { registerHistoryAggregatorHandlers } = require('./historyAggregator.cjs');
 const memoryTool = require('./memoryTool.cjs');
+const agentMemory = require('./agentMemory.cjs');
 const { registerDocEditorHandlers } = require('./docEditor.cjs');
+const git = require('./git.cjs');
+const superagent = require('./superagent.cjs');
+const { registerProjectSkillsHandlers } = require('./projectSkills.cjs');
+const filesIpc = require('./files.cjs');
 const { resolveClaudeBin } = require('./lib/claudeBin.cjs');
 const { assertCwdInsideHome } = require('./lib/insideHome.cjs');
 
@@ -184,6 +189,7 @@ async function rebootApp() {
     scheduler.attachWindow(mainWindow);
     watchers.attachWindow(mainWindow);
     pluginInstall.attachWindow(mainWindow);
+    superagent.attachWindow(mainWindow);
     rebooting = false;
     return;
   }
@@ -630,7 +636,12 @@ queueOps.registerQueueOpsHandlers();
 registerHistoryAggregatorHandlers();
 pluginInstall.registerPluginInstallHandlers();
 memoryTool.registerMemoryHandlers();
+agentMemory.registerAgentMemoryHandlers();
 registerDocEditorHandlers();
+git.register(ipcMain);
+superagent.registerSuperAgentHandlers();
+registerProjectSkillsHandlers();
+filesIpc.registerFilesHandlers();
 
 // OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
 ipcMain.handle('otel:get-config', async () => otelSettings.load());
@@ -842,6 +853,7 @@ app.whenReady().then(async () => {
   scheduler.attachWindow(mainWindow);
   watchers.attachWindow(mainWindow);
   pluginInstall.attachWindow(mainWindow);
+  superagent.attachWindow(mainWindow);
   scheduler.init().catch((e) => {
     logs.writeLine({ scope: 'scheduler', level: 'error', message: 'init failed', meta: { error: e?.message } });
   });

package/src/main/ipcSchemas.cjs

@@ -212,6 +212,36 @@ const memoryCreate = z.object({
   description: z.string().max(2048).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Per-subagent memory
+// Distinct from the workspace-scoped Memory tool: agentMemory is keyed by
+// subagent name (the .md filename in ~/.claude/agents/, e.g. "code-reviewer"),
+// not by cwd. Storage lives at ~/.claude/session-manager/agent-memory/<agentId>.json.
+// Regex caps must stay in lockstep with agentMemory.cjs AGENT_ID_RE / ENTRY_ID_RE.
+const AGENT_MEMORY_ID_RE = /^[A-Za-z0-9._-]{1,128}$/;
+const AGENT_MEMORY_CATEGORY = z.enum(['command', 'preference', 'pattern', 'failure', 'workflow']);
+const AGENT_MEMORY_MAX_BODY = 1024 * 1024; // 1 MiB — must match MAX_BODY_BYTES in agentMemory.cjs
+
+const agentMemoryList = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
+const agentMemoryGet = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
+const agentMemorySet = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+  body: z.string().max(AGENT_MEMORY_MAX_BODY),
+  category: AGENT_MEMORY_CATEGORY.optional(),
+}).strict();
+
+const agentMemoryDelete = z.object({
+  agentId: z.string().regex(AGENT_MEMORY_ID_RE),
+  entryId: z.string().regex(AGENT_MEMORY_ID_RE),
+}).strict();
+
 // ──────────────────────────────────────────── History
 const DATE_YYYY_MM_DD = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -283,6 +313,16 @@ const appGitBranch = z.object({
   cwd: z.string().min(1).max(4096),
 }).passthrough();
 
+// git:status / git:file-status — see src/main/git.cjs. cwd is validatePath'd
+// inside the handler (allowedRoots = home), so the schema only enforces shape.
+const gitStatus = z.object({
+  cwd: z.string().min(1).max(4096),
+}).passthrough();
+
+const gitFileStatus = z.object({
+  cwd: z.string().min(1).max(4096),
+}).passthrough();
+
 // Plugin install: mirrors pluginInstall.cjs SLUG_RE + length cap. Defense in
 // depth — install() re-checks; the schema rejects earlier.
 const PLUGIN_SLUG_RE = /^[a-z0-9\-/]+$/;
@@ -290,6 +330,20 @@ const pluginsInstall = z.object({
   slug: z.string().regex(PLUGIN_SLUG_RE).min(1).max(128),
 }).passthrough();
 
+// SuperAgent — "boss" run that writes a structured prompt to the active
+// tab's PTY. Bounds match the inline schemas in superagent.cjs; centralizing
+// here so the schema is the boundary fence rather than each handler.
+const superagentStart = z.object({
+  tabId: z.string().min(1).max(128),
+  prompt: z.string().min(1).max(8 * 1024),
+  specialistCount: z.number().int().min(1).max(8),
+  depth: z.enum(['quick', 'standard', 'deep']),
+}).strict();
+
+const superagentTabId = z.object({
+  tabId: z.string().min(1).max(128),
+}).strict();
+
 /**
  * Wrap an IPC handler with schema validation. Returns a new handler that
  * parses the payload before calling the original. On invalid payload throws
@@ -342,12 +396,20 @@ module.exports = {
     voiceSetRecording,
     appTestFireHook,
     appGitBranch,
+    gitStatus,
+    gitFileStatus,
     pluginsInstall,
+    superagentStart,
+    superagentTabId,
     memoryList,
     memoryRead,
     memoryWrite,
     memoryDelete,
     memoryCreate,
+    agentMemoryList,
+    agentMemoryGet,
+    agentMemorySet,
+    agentMemoryDelete,
     watchersAdd,
     watchersList,
     watchersRemove,

package/src/main/projectSkills.cjs

@@ -0,0 +1,124 @@
+/**
+ * ProjectSkills — per-project skill enable/disable state.
+ *
+ * Storage: <cwd>/.claude/project-skills.json
+ *   Format: { skills: Array<{ skillId: string; enabled: boolean }>, schemaVersion: 1 }
+ *
+ * Reads enumerate all skills under <cwd>/.claude/skills/ and <home>/.claude/skills/
+ * and merge their enable state from the project-local config. Skills not listed in
+ * the JSON default to `enabled: true` (i.e., opt-out per project).
+ *
+ * IPC:
+ *   - project-skills:get(cwd) -> SkillState[]
+ *   - project-skills:set(cwd, skillId, enabled) -> { ok: boolean }
+ *
+ * Atomic writes go through config.cjs::writeJson. cwd is validated via
+ * validatePath which constrains it to allowedRoots (home + registered project
+ * dirs).
+ */
+
+const { ipcMain } = require('electron');
+const path = require('node:path');
+const { z } = require('zod');
+const { readJson, writeJson, addAllowedRoot } = require('./config.cjs');
+
+const SCHEMA_VERSION = 1;
+
+function projectSkillsPath(cwd) {
+  return path.join(cwd, '.claude', 'project-skills.json');
+}
+
+/**
+ * Load the project-skills.json record for a cwd. Missing file => empty record.
+ * Returns { skills: Array<{skillId, enabled}>, schemaVersion }.
+ */
+async function loadRecord(cwd) {
+  const filePath = projectSkillsPath(cwd);
+  const r = await readJson(filePath);
+  if (!r.exists || !r.data || typeof r.data !== 'object') {
+    return { skills: [], schemaVersion: SCHEMA_VERSION };
+  }
+  const data = r.data;
+  const skills = Array.isArray(data.skills) ? data.skills : [];
+  // Filter for well-formed entries; tolerate corruption silently.
+  const clean = [];
+  const seen = new Set();
+  for (const s of skills) {
+    if (!s || typeof s.skillId !== 'string' || typeof s.enabled !== 'boolean') continue;
+    if (seen.has(s.skillId)) continue;
+    seen.add(s.skillId);
+    clean.push({ skillId: s.skillId, enabled: s.enabled });
+  }
+  return { skills: clean, schemaVersion: SCHEMA_VERSION };
+}
+
+async function saveRecord(cwd, record) {
+  const filePath = projectSkillsPath(cwd);
+  const payload = {
+    schemaVersion: SCHEMA_VERSION,
+    skills: record.skills,
+    savedAt: Date.now(),
+  };
+  return writeJson(filePath, payload);
+}
+
+/** Return the array of skill enable-states for a project cwd. */
+async function getProjectSkills(cwd) {
+  // Register cwd so writeJson is permitted under <cwd>/.claude.
+  addAllowedRoot(cwd);
+  const record = await loadRecord(cwd);
+  return record.skills;
+}
+
+/** Upsert a single skillId's enabled flag. */
+async function setProjectSkill(cwd, skillId, enabled) {
+  addAllowedRoot(cwd);
+  const record = await loadRecord(cwd);
+  const idx = record.skills.findIndex((s) => s.skillId === skillId);
+  if (idx >= 0) {
+    record.skills[idx] = { skillId, enabled };
+  } else {
+    record.skills.push({ skillId, enabled });
+  }
+  await saveRecord(cwd, record);
+  return { ok: true };
+}
+
+// ──────────────────────────────────────────── IPC schemas
+const projectSkillsCwd = z.object({
+  cwd: z.string().min(1).max(4096),
+});
+
+const projectSkillsSet = z.object({
+  cwd: z.string().min(1).max(4096),
+  skillId: z.string().min(1).max(256),
+  enabled: z.boolean(),
+});
+
+function validated(schema, handler) {
+  return (_event, payload) => {
+    const parsed = schema.parse(payload);
+    return handler(parsed);
+  };
+}
+
+function registerProjectSkillsHandlers() {
+  ipcMain.handle(
+    'project-skills:get',
+    validated(projectSkillsCwd, ({ cwd }) => getProjectSkills(cwd)),
+  );
+  ipcMain.handle(
+    'project-skills:set',
+    validated(projectSkillsSet, ({ cwd, skillId, enabled }) =>
+      setProjectSkill(cwd, skillId, enabled),
+    ),
+  );
+}
+
+module.exports = {
+  registerProjectSkillsHandlers,
+  // Exported for tests / direct use.
+  getProjectSkills,
+  setProjectSkill,
+  projectSkillsPath,
+};

package/src/main/superagent.cjs

@@ -0,0 +1,202 @@
+/**
+ * SuperAgent — "boss" runner that dispatches specialist subagents.
+ *
+ * Ported (in MVP form) from ClaudeCodeUnleashed's SuperAgent feature.
+ * Differs significantly from upstream:
+ *   - We don't call Groq/OpenAI. The boss IS Claude — we send a structured
+ *     prompt to the active PTY tab asking Claude to act as the boss, pick
+ *     specialists, and report progress in a parseable format.
+ *   - No autonomous output-parsing / fast-path / WAIT logic. State machine
+ *     is renderer-driven via transcript events (see live.ts pattern).
+ *   - Per-tab run state lives here so the renderer can poll status across
+ *     navigation, and so a future supervisor probe can act on stuck runs.
+ *
+ * Channels:
+ *   superagent:start({ tabId, prompt, specialistCount, depth })
+ *     → { ok, error? } and broadcasts the boss prompt to the tab's PTY.
+ *   superagent:status(tabId) → SuperAgentRunState | null
+ *   superagent:stop(tabId) → { ok }
+ *
+ * Broadcasts:
+ *   superagent:state-changed → { tabId, state } whenever a run starts/stops.
+ *
+ * The PTY write is intentionally done via the existing ptyManager.write
+ * indirection, NOT a fresh spawn — SuperAgent runs inside the user's current
+ * Claude session.
+ */
+
+const { ipcMain } = require('electron');
+const { schemas } = require('./ipcSchemas.cjs');
+const { manager: ptyManager } = require('./pty.cjs');
+const logs = require('./logs.cjs');
+
+// Per-tab run state. Single live run per tab — starting a new run on a tab
+// that's already running stops the existing one first.
+//
+// Shape (also exposed on the renderer via api.d.ts SuperAgentRunState):
+//   { status: 'idle' | 'running' | 'done' | 'error',
+//     prompt, specialistCount, depth,
+//     startedAt: number | null, finishedAt: number | null,
+//     error?: string }
+const runs = new Map();
+
+let mainWindow = null;
+
+function attachWindow(win) {
+  mainWindow = win;
+}
+
+function broadcast(tabId) {
+  if (!mainWindow || mainWindow.isDestroyed()) return;
+  const state = runs.get(tabId) ?? null;
+  try {
+    mainWindow.webContents.send('superagent:state-changed', { tabId, state });
+  } catch { /* renderer gone */ }
+}
+
+/**
+ * Build the prompt we send to Claude to act as the boss. Structured so the
+ * renderer can (in a follow-up) pattern-match progress markers off the
+ * transcript without us having to parse PTY output ourselves.
+ *
+ * O(1) string concat — the prompt is bounded by the zod max(8KiB).
+ */
+function buildBossPrompt({ prompt, specialistCount, depth }) {
+  const depthLine = depth === 'quick'
+    ? 'Quick pass — surface-level analysis, single-shot specialist work.'
+    : depth === 'deep'
+      ? 'Deep pass — multi-step plans per specialist, recurse on findings.'
+      : 'Standard pass — moderate detail, one or two iterations per specialist.';
+
+  return [
+    '## SuperAgent boss mode',
+    '',
+    `You are coordinating ${specialistCount} specialist subagent(s) for the user's task.`,
+    depthLine,
+    '',
+    'Workflow:',
+    `  1. Pick ${specialistCount} specialist subagent type(s) that best match the task.`,
+    '     Report them as: [SUPERAGENT] specialists: <type1>, <type2>, ...',
+    '  2. Dispatch them via the Task tool, one at a time or in parallel as appropriate.',
+    '  3. After each specialist returns, report: [SUPERAGENT] progress: <specialist> done',
+    '  4. When the task is complete, summarize results and report: [SUPERAGENT] complete',
+    '',
+    'User task:',
+    prompt,
+  ].join('\n');
+}
+
+function startRun(payload) {
+  const { tabId, prompt, specialistCount, depth } = payload;
+
+  // Stop any in-flight run on this tab — single run-per-tab invariant.
+  const existing = runs.get(tabId);
+  if (existing && existing.status === 'running') {
+    runs.set(tabId, {
+      ...existing,
+      status: 'done',
+      finishedAt: Date.now(),
+    });
+  }
+
+  const fullPrompt = buildBossPrompt({ prompt, specialistCount, depth });
+
+  // PTY write — exactly the pattern docstring'd at the top of the task brief.
+  // The trailing carriage-return submits the prompt in Claude's TUI.
+  let writeErr = null;
+  try {
+    ptyManager.write({ tabId, data: fullPrompt + '\r' });
+  } catch (e) {
+    writeErr = e?.message ?? String(e);
+  }
+
+  if (writeErr) {
+    const errState = {
+      status: 'error',
+      prompt,
+      specialistCount,
+      depth,
+      startedAt: Date.now(),
+      finishedAt: Date.now(),
+      error: writeErr,
+    };
+    runs.set(tabId, errState);
+    broadcast(tabId);
+    logs.writeLine({
+      scope: 'superagent',
+      level: 'error',
+      message: 'start failed',
+      meta: { tabId, error: writeErr },
+    });
+    return { ok: false, error: writeErr };
+  }
+
+  const state = {
+    status: 'running',
+    prompt,
+    specialistCount,
+    depth,
+    startedAt: Date.now(),
+    finishedAt: null,
+  };
+  runs.set(tabId, state);
+  broadcast(tabId);
+
+  logs.writeLine({
+    scope: 'superagent',
+    level: 'info',
+    message: 'start',
+    meta: { tabId, specialistCount, depth, promptBytes: prompt.length },
+  });
+
+  return { ok: true };
+}
+
+function stopRun(tabId) {
+  const existing = runs.get(tabId);
+  if (!existing || existing.status !== 'running') {
+    return { ok: true };
+  }
+  runs.set(tabId, {
+    ...existing,
+    status: 'done',
+    finishedAt: Date.now(),
+  });
+  broadcast(tabId);
+  logs.writeLine({
+    scope: 'superagent',
+    level: 'info',
+    message: 'stop',
+    meta: { tabId },
+  });
+  return { ok: true };
+}
+
+function getStatus(tabId) {
+  return runs.get(tabId) ?? null;
+}
+
+function registerSuperAgentHandlers() {
+  ipcMain.handle('superagent:start', (_e, payload) => {
+    const parsed = schemas.superagentStart.parse(payload);
+    return startRun(parsed);
+  });
+
+  ipcMain.handle('superagent:status', (_e, payload) => {
+    const { tabId } = schemas.superagentTabId.parse(payload);
+    return getStatus(tabId);
+  });
+
+  ipcMain.handle('superagent:stop', (_e, payload) => {
+    const { tabId } = schemas.superagentTabId.parse(payload);
+    return stopRun(tabId);
+  });
+}
+
+module.exports = {
+  attachWindow,
+  registerSuperAgentHandlers,
+  // Exposed for tests.
+  buildBossPrompt,
+  _runs: runs,
+};