claude-code-session-manager 0.38.5 → 0.38.7

package/src/main/hives.cjs

@@ -1,287 +0,0 @@
-/**
- * hives.cjs — subagent recipe templates ("Hives").
- *
- * A Recipe is a named sequence of steps, each referencing an agent by name
- * from `~/.claude/agents/<agentName>.md`. Shape:
- *   { slug, name, description, brief?, steps: [{ agentName, note? }] }
- *
- * Legacy hives (old shape: `roles: [{ label, prompt }]`) are migrated on
- * first read: each role is materialized as an agent .md and replaced by a
- * step referencing it. Migration is idempotent and permanent (re-saved).
- *
- * Storage: `~/.claude/session-manager/hives/<slug>.json`
- *   - slug must match SLUG_RE: /^[a-z0-9-_]{1,64}$/
- *   - up to 32 steps per recipe
- *   - per-field byte caps mirrored in the inline zod schemas below
- *
- * IPC namespace (channel names kept for backwards compat):
- *   - hives:list   -> { hives: Recipe[], error: string | null }
- *   - hives:get    -> { hive: Recipe | null, error: string | null }
- *   - hives:save   -> { ok: boolean, error: string | null }
- *   - hives:delete -> { ok: boolean, error: string | null }
- *
- * All mutations go through config.cjs::writeJson / writeTextAtomic (atomic
- * tmp+rename) and config.cjs::validatePath (allowedRoots = home dir).
- * Never raw fs.writeFile.
- */
-
-'use strict';
-
-const { ipcMain } = require('electron');
-const fsp = require('node:fs/promises');
-const path = require('node:path');
-const os = require('node:os');
-const { z } = require('zod');
-const config = require('./config.cjs');
-const { kebabCase: sharedKebabCase } = require('./lib/kebabCase.cjs');
-
-// ──────────────────────────────────────────── caps
-const SLUG_RE = /^[a-z0-9-_]{1,64}$/;
-const AGENT_NAME_RE = /^[a-z0-9-_]{1,64}$/;
-const MAX_NAME_LEN = 128;
-const MAX_DESC_LEN = 2048;
-const MAX_BRIEF_LEN = 8 * 1024;
-const MAX_NOTE_LEN = 2048;
-const MAX_STEPS = 32;
-
-// ──────────────────────────────────────────── inline zod schemas
-const recipeStepSchema = z.object({
-  agentName: z.string().regex(AGENT_NAME_RE),
-  note: z.string().max(MAX_NOTE_LEN).optional(),
-}).strict();
-
-const recipeSchema = z.object({
-  slug: z.string().regex(SLUG_RE),
-  name: z.string().min(1).max(MAX_NAME_LEN),
-  description: z.string().max(MAX_DESC_LEN).default(''),
-  brief: z.string().max(MAX_BRIEF_LEN).optional(),
-  steps: z.array(recipeStepSchema).min(1).max(MAX_STEPS),
-}).strict();
-
-const slugPayload = z.object({
-  slug: z.string().regex(SLUG_RE),
-}).strict();
-
-// Field name "hive" kept for IPC channel backwards compatibility.
-const savePayload = z.object({
-  slug: z.string().regex(SLUG_RE),
-  hive: recipeSchema,
-}).strict();
-
-// ──────────────────────────────────────────── paths
-function rootDir() {
-  return path.join(os.homedir(), '.claude', 'session-manager', 'hives');
-}
-
-function agentsDir() {
-  return path.join(os.homedir(), '.claude', 'agents');
-}
-
-function hivePath(slug) {
-  if (!SLUG_RE.test(slug)) {
-    throw new Error(`invalid hive slug (must match ${SLUG_RE.source})`);
-  }
-  return path.join(rootDir(), `${slug}.json`);
-}
-
-async function ensureRoot() {
-  await fsp.mkdir(rootDir(), { recursive: true });
-}
-
-// ──────────────────────────────────────────── helpers
-function kebabCase(s) {
-  return sharedKebabCase(s, { maxLen: 64, fallback: 'agent' });
-}
-
-// ──────────────────────────────────────────── legacy migration
-async function migrateLegacyHive(slug, raw) {
-  const adir = agentsDir();
-  await fsp.mkdir(adir, { recursive: true });
-
-  const usedNames = new Set();
-  const steps = [];
-
-  for (const role of (raw.roles ?? [])) {
-    let base = kebabCase(role.label ?? 'agent');
-    let agentName = base;
-    let suffix = 2;
-    while (usedNames.has(agentName)) {
-      agentName = `${base.slice(0, 62)}-${suffix++}`;
-    }
-    usedNames.add(agentName);
-
-    const agentFilePath = path.join(adir, `${agentName}.md`);
-    // validatePath ensures we stay within allowedRoots (home dir).
-    const validPath = config.validatePath(agentFilePath);
-
-    let exists = false;
-    try { await fsp.stat(validPath); exists = true; } catch { /* ENOENT = not yet created */ }
-
-    if (!exists) {
-      const descLine = (role.prompt ?? '').replace(/[\r\n]+/g, ' ').slice(0, 200);
-      const content = `---\nname: ${role.label}\ndescription: ${descLine}\n---\n\n${role.prompt ?? ''}\n`;
-      await config.writeTextAtomic(validPath, content);
-    }
-
-    steps.push({ agentName });
-  }
-
-  const recipe = {
-    slug,
-    name: raw.name,
-    description: raw.description ?? '',
-    steps,
-    ...(raw.defaultPlan ? { brief: raw.defaultPlan } : {}),
-  };
-
-  // Persist migrated shape permanently so subsequent reads skip migration.
-  await saveHive(slug, recipe);
-
-  return { hive: recipe, error: null };
-}
-
-// ──────────────────────────────────────────── core ops
-async function listHives() {
-  try {
-    await ensureRoot();
-    const r = await config.listDir(rootDir(), { filesOnly: true });
-    if (!r.ok) return { hives: [], error: r.error };
-    const slugs = r.entries
-      .filter((e) => e.name.endsWith('.json'))
-      .map((e) => e.name.replace(/\.json$/, ''))
-      .filter((s) => SLUG_RE.test(s));
-    // Load each in parallel. Skip any that fail to parse cleanly.
-    const hives = await Promise.all(
-      slugs.map(async (slug) => {
-        try {
-          const got = await readHive(slug);
-          return got.hive;
-        } catch {
-          return null;
-        }
-      }),
-    );
-    return {
-      hives: hives.filter((h) => h !== null).sort((a, b) => a.slug.localeCompare(b.slug)),
-      error: null,
-    };
-  } catch (e) {
-    return { hives: [], error: e.message };
-  }
-}
-
-async function readHive(slug) {
-  const abs = hivePath(slug);
-  const r = await config.readJson(abs);
-  if (!r || !r.exists) return { hive: null, error: null };
-  if (r.parseError) return { hive: null, error: `parse error: ${r.parseError}` };
-
-  const raw = r.data;
-
-  // Legacy migration: old shape has `roles` array instead of `steps`.
-  if (raw && Array.isArray(raw.roles) && !Array.isArray(raw.steps)) {
-    return migrateLegacyHive(slug, raw);
-  }
-
-  // Re-validate stored shape so a hand-edited file can't smuggle in bad data.
-  const parsed = recipeSchema.safeParse(raw);
-  if (!parsed.success) {
-    return { hive: null, error: `invalid recipe on disk: ${parsed.error.issues[0]?.message ?? 'unknown'}` };
-  }
-  // Trust the file's own slug only if it matches the filename; filename wins.
-  const hive = { ...parsed.data, slug };
-  return { hive, error: null };
-}
-
-async function getHive(slug) {
-  try {
-    return await readHive(slug);
-  } catch (e) {
-    return { hive: null, error: e.message };
-  }
-}
-
-async function saveHive(slug, hive) {
-  try {
-    // Body slug must match path slug.
-    if (hive.slug !== slug) {
-      return { ok: false, error: `slug mismatch: payload slug "${hive.slug}" != path "${slug}"` };
-    }
-    await ensureRoot();
-    const abs = hivePath(slug);
-    const out = {
-      ...hive,
-      description: hive.description ?? '',
-    };
-    if (out.brief === undefined || out.brief === '') delete out.brief;
-    const result = await config.writeJson(abs, out);
-    if (!result || !result.ok) {
-      return { ok: false, error: result?.error ?? 'write failed' };
-    }
-    return { ok: true, error: null };
-  } catch (e) {
-    return { ok: false, error: e.message };
-  }
-}
-
-async function deleteHive(slug) {
-  try {
-    const abs = hivePath(slug);
-    let real;
-    try {
-      real = config.validatePath(abs);
-      if (typeof config.validateWrite === 'function') {
-        config.validateWrite(real);
-      }
-    } catch (e) {
-      return { ok: false, error: e.message };
-    }
-    try {
-      await fsp.unlink(real);
-    } catch (e) {
-      if (e.code === 'ENOENT') {
-        return { ok: true, error: null };
-      }
-      return { ok: false, error: e.message };
-    }
-    return { ok: true, error: null };
-  } catch (e) {
-    return { ok: false, error: e.message };
-  }
-}
-
-// ──────────────────────────────────────────── IPC
-function validated(schema, handler) {
-  return (_event, payload) => {
-    const parsed = schema.parse(payload);
-    return handler(parsed);
-  };
-}
-
-function registerHiveHandlers() {
-  ipcMain.handle('hives:list', () => listHives());
-  ipcMain.handle(
-    'hives:get',
-    validated(slugPayload, ({ slug }) => getHive(slug)),
-  );
-  ipcMain.handle(
-    'hives:save',
-    validated(savePayload, ({ slug, hive }) => saveHive(slug, hive)),
-  );
-  ipcMain.handle(
-    'hives:delete',
-    validated(slugPayload, ({ slug }) => deleteHive(slug)),
-  );
-}
-
-module.exports = {
-  registerHiveHandlers,
-  // exported for tests
-  rootDir,
-  hivePath,
-  SLUG_RE,
-  listHives,
-  getHive,
-  saveHive,
-  deleteHive,
-};

package/src/main/superagent.cjs

@@ -1,212 +0,0 @@
-/**
- * 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 dropTab(tabId) {
-  if (runs.has(tabId)) {
-    runs.delete(tabId);
-    if (process.env.SM_DEBUG_LEAKS === '1') {
-      console.log('[superagent] dropTab', tabId, 'runs.size=', runs.size);
-    }
-  }
-}
-
-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,
-  dropTab,
-  // Exposed for tests.
-  buildBossPrompt,
-  _runs: runs,
-};