claude-code-session-manager 0.10.2 → 0.11.0

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,
+};

package/src/main/transcripts.cjs

@@ -69,7 +69,9 @@ function classifyLine(obj) {
           return { kind: 'plan', data: block.input, raw: obj };
         }
         if (block.name === 'Agent' || block.name === 'Task') {
-          return { kind: 'agent_spawn', data: block.input, raw: obj };
+          // Include block.id as toolUseId so the live store can match the
+          // corresponding tool_result and update per-agent lastActivityAt.
+          return { kind: 'agent_spawn', data: { ...block.input, toolUseId: block.id }, raw: obj };
         }
         return {
           kind: 'tool_use',
@@ -77,6 +79,11 @@ function classifyLine(obj) {
           raw: obj,
         };
       }
+      // tool_result carries the tool_use_id of the completed Task/Agent call.
+      // The live store uses this to update the agent's lastActivityAt bookend.
+      if (block?.type === 'tool_result' && block.tool_use_id) {
+        return { kind: 'tool_result', data: { toolUseId: block.tool_use_id }, raw: obj };
+      }
     }
   }
 

package/src/preload/api.d.ts

@@ -377,6 +377,46 @@ export interface HistoryAggregateResult {
   scannedMs: number;
 }
 
+export interface ConversationSummary {
+  /** ISO 8601 timestamp of the first event in the conversation (or file mtime fallback). */
+  timestamp: string;
+  /** Decoded project cwd, e.g. /home/user/Projects/foo. */
+  projectFolder: string;
+  stats: {
+    /** Wall-clock duration in ms (first event ts → last event ts). Omitted when unknown. */
+    duration?: number;
+    /** Sum of input + output tokens across the file. 0 when no usage blocks present. */
+    estimatedTokens: number;
+  };
+}
+
+export interface ListConversationsResult {
+  conversations: ConversationSummary[];
+  scannedMs: number;
+}
+
+export interface ProjectSkillState {
+  skillId: string;
+  enabled: boolean;
+}
+
+export interface FileEntry {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  isFile: boolean;
+  size: number;
+  mtimeMs: number;
+}
+
+export interface FilesListResult { ok: boolean; entries: FileEntry[]; error: string | null }
+export interface FilesReadResult { ok: boolean; text: string; error: string | null; size: number }
+export interface FilesWriteResult { ok: boolean; error: string | null }
+export interface FilesCreateResult { ok: boolean; path?: string; error: string | null }
+export interface FilesRenameResult { ok: boolean; newPath?: string; error: string | null }
+export interface FilesDeleteResult { ok: boolean; error: string | null }
+export interface FilesShellResult { ok: boolean; error?: string }
+
 export interface WatcherInfo {
   watcherId: string;
   tabId: string;
@@ -506,6 +546,83 @@ export interface MemoryMutationResult {
   error: string | null;
 }
 
+// ────────────────────────────────────────────── Per-subagent memory
+// Stored at ~/.claude/session-manager/agent-memory/<agentId>.json. Keyed by
+// agent name (the .md filename in ~/.claude/agents/), not by workspace cwd.
+
+export type AgentMemoryCategory = 'command' | 'preference' | 'pattern' | 'failure' | 'workflow';
+
+export interface AgentMemoryEntry {
+  id: string;
+  body: string;
+  category: AgentMemoryCategory | null;
+  createdAt: number;
+  updatedAt: number;
+  bytes: number;
+}
+
+export interface AgentMemoryListResult {
+  entries: AgentMemoryEntry[];
+  agentId: string;
+  error: string | null;
+}
+
+export interface AgentMemoryGetResult {
+  entry: AgentMemoryEntry | null;
+  error: string | null;
+}
+
+export interface AgentMemoryMutationResult {
+  ok: boolean;
+  error: string | null;
+}
+
+export interface AgentMemoryAgentSummary {
+  agentId: string;
+  bytes: number;
+  mtimeMs: number;
+}
+
+export interface AgentMemoryListAgentsResult {
+  agents: AgentMemoryAgentSummary[];
+  error: string | null;
+}
+
+// ────────────────────────────────────────────── Git status (richer than app:git-branch)
+
+/** Mirrors the status returned by src/main/git.cjs mapStatus(). */
+export type GitFileStatusType =
+  | 'modified'
+  | 'added'
+  | 'deleted'
+  | 'renamed'
+  | 'untracked'
+  | 'staged'
+  | 'conflict';
+
+export interface GitFileStatus {
+  /** Absolute path. Always inside cwd (we resolve relative paths against it). */
+  path: string;
+  /** Path as git reported it, relative to the repo root. */
+  relativePath: string;
+  status: GitFileStatusType;
+  /** Raw porcelain X (index) character. ' ', 'M', 'A', 'D', 'R', 'C', 'U', '?'. */
+  indexStatus: string;
+  /** Raw porcelain Y (worktree) character. ' ', 'M', 'D', 'U', '?'. */
+  workTreeStatus: string;
+}
+
+export interface GitStatusResult {
+  branch: string;
+  ahead: number;
+  behind: number;
+  uncommittedCount: number;
+  files: GitFileStatus[];
+}
+
+/** Map keyed by absolute path. Same enum as GitFileStatus.status. */
+export type GitFileStatusMap = Record<string, GitFileStatusType>;
+
 // ────────────────────────────────────────────── Bundle F — plugins install
 
 export interface PluginInstallResult {
@@ -519,6 +636,40 @@ export interface PluginInstallProgressEvent {
   line: string;
 }
 
+// ────────────────────────────────────────────── SuperAgent
+// "Boss" run that dispatches specialist subagents on the active tab's claude
+// session. Renderer-driven progress — main only owns lifecycle + prompt write.
+
+export type SuperAgentDepth = 'quick' | 'standard' | 'deep';
+export type SuperAgentStatus = 'idle' | 'running' | 'done' | 'error';
+
+export interface SuperAgentRunState {
+  status: SuperAgentStatus;
+  prompt: string;
+  specialistCount: number;
+  depth: SuperAgentDepth;
+  startedAt: number | null;
+  finishedAt: number | null;
+  error?: string;
+}
+
+export interface SuperAgentStartArgs {
+  tabId: string;
+  prompt: string;
+  specialistCount: number;
+  depth: SuperAgentDepth;
+}
+
+export interface SuperAgentStartResult {
+  ok: boolean;
+  error?: string;
+}
+
+export interface SuperAgentStateChangedEvent {
+  tabId: string;
+  state: SuperAgentRunState | null;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -540,6 +691,13 @@ export interface SessionManagerAPI {
     onNewSession: (handler: () => void) => () => void;
     onRebootSession: (handler: () => void) => () => void;
     openInEditor: (cwd: string, editor?: string | null) => Promise<{ ok: boolean; editor?: string; error?: string }>;
+    /** Open an http/https URL in the OS default browser. file://, javascript:,
+     *  and other schemes are rejected with `ok:false` to prevent abuse. */
+    openExternal: (url: string) => Promise<{ ok: boolean; error?: string }>;
+    /** Open a specific file at line:col in the user's editor. Editors with
+     *  goto-line support (code/cursor/subl) get the `-g file:line:col` form;
+     *  others open the file alone. */
+    openFileInEditor: (filePath: string, line?: number, col?: number, 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 }>;
@@ -616,8 +774,23 @@ export interface SessionManagerAPI {
     status: () => Promise<OtelStatus>;
     configPath: () => Promise<string>;
   };
+  projectSkills: {
+    get: (cwd: string) => Promise<ProjectSkillState[]>;
+    set: (cwd: string, skillId: string, enabled: boolean) => Promise<{ ok: boolean }>;
+  };
+  files: {
+    list: (path: string, showHidden?: boolean) => Promise<FilesListResult>;
+    read: (path: string) => Promise<FilesReadResult>;
+    write: (path: string, content: string) => Promise<FilesWriteResult>;
+    create: (parentPath: string, name: string, kind: 'file' | 'folder') => Promise<FilesCreateResult>;
+    rename: (path: string, newName: string) => Promise<FilesRenameResult>;
+    delete: (path: string) => Promise<FilesDeleteResult>;
+    openExternal: (path: string) => Promise<FilesShellResult>;
+    showInFinder: (path: string) => Promise<FilesShellResult>;
+  };
   history: {
     aggregate: (req?: HistoryAggregateRequest) => Promise<HistoryAggregateResult>;
+    listConversations: () => Promise<ListConversationsResult>;
   };
   schedule: {
     state: () => Promise<ScheduleStateSnapshot>;
@@ -683,6 +856,48 @@ export interface SessionManagerAPI {
     /** Create a new memory entry with starter frontmatter + body. */
     create: (name: string, description?: string, workspace?: string) => Promise<MemoryMutationResult>;
   };
+  agentMemory: {
+    /** List all memory entries for one subagent. Sorted newest first. */
+    list: (agentId: string) => Promise<AgentMemoryListResult>;
+    /** Get one entry's full body. Returns `{entry:null}` if missing. */
+    get: (agentId: string, entryId: string) => Promise<AgentMemoryGetResult>;
+    /** Upsert one entry. Atomic write through config.cjs; max body 1 MiB. */
+    set: (
+      agentId: string,
+      entryId: string,
+      body: string,
+      category?: AgentMemoryCategory,
+    ) => Promise<AgentMemoryMutationResult>;
+    /** Delete one entry. Removes the file outright when last entry is removed. */
+    delete: (agentId: string, entryId: string) => Promise<AgentMemoryMutationResult>;
+    /** List all agents that currently have a memory file on disk. */
+    listAgents: () => Promise<AgentMemoryListAgentsResult>;
+  };
+  docEditor: {
+    pickFile: (payload?: { lastDir?: string }) => Promise<{ path: string | null; error?: string }>;
+    readFile: (path: string) => Promise<{ ok: boolean; text?: string; mtimeMs?: number; error?: string }>;
+    writeFile: (path: string, text: string) => Promise<{ ok: boolean; mtimeMs?: number; error?: string }>;
+  };
+  git: {
+    /** Full git status for `cwd`. Returns null when not a git repo, git is
+     *  missing, or the call times out (5s ceiling). Cached per-cwd for 5s. */
+    status: (cwd: string) => Promise<GitStatusResult | null>;
+    /** `{ absPath: status }` map. Returns `{}` for non-git / errored cwds.
+     *  Same 5s cache as status(). Designed for a file-tree sidebar where the
+     *  renderer needs per-row badges without a separate git call per file. */
+    fileStatus: (cwd: string) => Promise<GitFileStatusMap>;
+  };
+  superagent: {
+    /** Start a SuperAgent boss run — writes a structured prompt to the tab's
+     *  PTY asking Claude to pick + dispatch specialists. Single run per tab. */
+    start: (args: SuperAgentStartArgs) => Promise<SuperAgentStartResult>;
+    /** Current run state for tab, or null if no run has been started. */
+    status: (tabId: string) => Promise<SuperAgentRunState | null>;
+    /** Mark the run as done. Does not interrupt Claude — the user can stop
+     *  the in-PTY work via Ctrl-C; this only flips the renderer indicator. */
+    stop: (tabId: string) => Promise<{ ok: boolean }>;
+    onStateChanged: (handler: (ev: SuperAgentStateChangedEvent) => void) => () => void;
+  };
 }
 
 declare global {

package/src/preload/index.cjs

@@ -10,6 +10,8 @@ contextBridge.exposeInMainWorld('api', {
     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 }),
+    openExternal: (url) => ipcRenderer.invoke('app:open-external', { url }),
+    openFileInEditor: (filePath, line, col, editor) => ipcRenderer.invoke('app:open-file-in-editor', { path: filePath, line, col, 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 }),
@@ -144,6 +146,22 @@ contextBridge.exposeInMainWorld('api', {
   },
   history: {
     aggregate: (req) => ipcRenderer.invoke('history:aggregate', req),
+    listConversations: () => ipcRenderer.invoke('history:list-conversations'),
+  },
+  projectSkills: {
+    get: (cwd) => ipcRenderer.invoke('project-skills:get', { cwd }),
+    set: (cwd, skillId, enabled) =>
+      ipcRenderer.invoke('project-skills:set', { cwd, skillId, enabled }),
+  },
+  files: {
+    list: (path, showHidden) => ipcRenderer.invoke('files:list', { path, showHidden }),
+    read: (path) => ipcRenderer.invoke('files:read', { path }),
+    write: (path, content) => ipcRenderer.invoke('files:write', { path, content }),
+    create: (parentPath, name, kind) => ipcRenderer.invoke('files:create', { parentPath, name, kind }),
+    rename: (path, newName) => ipcRenderer.invoke('files:rename', { path, newName }),
+    delete: (path) => ipcRenderer.invoke('files:delete', { path }),
+    openExternal: (path) => ipcRenderer.invoke('files:open-external', { path }),
+    showInFinder: (path) => ipcRenderer.invoke('files:show-in-finder', { path }),
   },
   schedule: {
     state: () => ipcRenderer.invoke('schedule:state'),
@@ -203,4 +221,40 @@ contextBridge.exposeInMainWorld('api', {
       return ipcRenderer.invoke('memory:create', payload);
     },
   },
+  agentMemory: {
+    list: (agentId) => ipcRenderer.invoke('agent-memory:list', { agentId }),
+    get: (agentId, entryId) => ipcRenderer.invoke('agent-memory:get', { agentId, entryId }),
+    set: (agentId, entryId, body, category) => {
+      const payload = { agentId, entryId, body };
+      if (category) payload.category = category;
+      return ipcRenderer.invoke('agent-memory:set', payload);
+    },
+    delete: (agentId, entryId) => ipcRenderer.invoke('agent-memory:delete', { agentId, entryId }),
+    listAgents: () => ipcRenderer.invoke('agent-memory:list-agents'),
+  },
+  docEditor: {
+    pickFile: (payload) => ipcRenderer.invoke('doc-editor:pick-file', payload),
+    readFile: (p) => ipcRenderer.invoke('doc-editor:read-file', { path: p }),
+    writeFile: (p, text) => ipcRenderer.invoke('doc-editor:write-file', { path: p, text }),
+  },
+  git: {
+    // Returns null when cwd is not a git repo, git is missing, or the call
+    // times out (5s ceiling). The existing `app.gitBranch` is intentionally
+    // kept — StatusBar still uses it for the cheap per-tab branch readout.
+    status: (cwd) => ipcRenderer.invoke('git:status', { cwd }),
+    fileStatus: (cwd) => ipcRenderer.invoke('git:file-status', { cwd }),
+  },
+  superagent: {
+    /** Start a SuperAgent boss run on a tab — writes a structured prompt to
+     *  the PTY asking Claude to pick + dispatch specialists. Single live run
+     *  per tab; starting again on a running tab terminates the prior one. */
+    start: (payload) => ipcRenderer.invoke('superagent:start', payload),
+    status: (tabId) => ipcRenderer.invoke('superagent:status', { tabId }),
+    stop: (tabId) => ipcRenderer.invoke('superagent:stop', { tabId }),
+    onStateChanged: (handler) => {
+      const listener = (_e, payload) => handler(payload);
+      ipcRenderer.on('superagent:state-changed', listener);
+      return () => ipcRenderer.removeListener('superagent:state-changed', listener);
+    },
+  },
 });