ai-agent-session-center 1.0.0

package/public/js/wsClient.js

@@ -0,0 +1,88 @@
+// WebSocket client with auto-reconnect
+let ws;
+let reconnectDelay = 1000;
+let onSnapshot = null;
+let onSessionUpdate = null;
+let onDurationAlert = null;
+let onTeamUpdate = null;
+let onHookStats = null;
+let onSessionRemoved = null;
+let onTerminalOutput = null;
+let onTerminalReady = null;
+let onTerminalClosed = null;
+let onClearBrowserDb = null;
+let reconnectTimer = null;
+let reconnectTarget = 0; // timestamp when reconnect fires
+
+export let connected = false;
+
+export function getReconnectRemaining() {
+  if (connected || !reconnectTarget) return 0;
+  return Math.max(0, Math.ceil((reconnectTarget - Date.now()) / 1000));
+}
+
+export function connect({ onSnapshotCb, onSessionUpdateCb, onSessionRemovedCb, onDurationAlertCb, onTeamUpdateCb, onHookStatsCb, onTerminalOutputCb, onTerminalReadyCb, onTerminalClosedCb, onClearBrowserDbCb }) {
+  onSnapshot = onSnapshotCb;
+  onSessionUpdate = onSessionUpdateCb;
+  onSessionRemoved = onSessionRemovedCb || null;
+  onDurationAlert = onDurationAlertCb;
+  onTeamUpdate = onTeamUpdateCb;
+  onHookStats = onHookStatsCb;
+  onTerminalOutput = onTerminalOutputCb || null;
+  onTerminalReady = onTerminalReadyCb || null;
+  onTerminalClosed = onTerminalClosedCb || null;
+  onClearBrowserDb = onClearBrowserDbCb || null;
+  _connect();
+}
+
+export function getWs() {
+  return ws;
+}
+
+function _connect() {
+  ws = new WebSocket(`ws://${window.location.host}`);
+
+  ws.onopen = () => {
+    reconnectDelay = 1000;
+    reconnectTarget = 0;
+    connected = true;
+    console.log('[WS] Connected');
+    document.dispatchEvent(new CustomEvent('ws-status', { detail: 'connected' }));
+  };
+
+  ws.onmessage = (event) => {
+    const data = JSON.parse(event.data);
+    if (data.type === 'snapshot' && onSnapshot) {
+      onSnapshot(data.sessions, data.teams);
+    } else if (data.type === 'session_update' && onSessionUpdate) {
+      onSessionUpdate(data.session, data.team);
+    } else if (data.type === 'session_removed' && onSessionRemoved) {
+      onSessionRemoved(data.sessionId);
+    } else if (data.type === 'team_update' && onTeamUpdate) {
+      onTeamUpdate(data.team);
+    } else if (data.type === 'hook_stats' && onHookStats) {
+      onHookStats(data.stats);
+    } else if (data.type === 'duration_alert' && onDurationAlert) {
+      onDurationAlert(data);
+    } else if (data.type === 'terminal_output' && onTerminalOutput) {
+      onTerminalOutput(data.terminalId, data.data);
+    } else if (data.type === 'terminal_ready' && onTerminalReady) {
+      onTerminalReady(data.terminalId);
+    } else if (data.type === 'terminal_closed' && onTerminalClosed) {
+      onTerminalClosed(data.terminalId, data.reason);
+    } else if (data.type === 'clearBrowserDb' && onClearBrowserDb) {
+      onClearBrowserDb();
+    }
+  };
+
+  ws.onclose = () => {
+    connected = false;
+    console.log(`[WS] Disconnected, reconnecting in ${reconnectDelay}ms`);
+    document.dispatchEvent(new CustomEvent('ws-status', { detail: 'disconnected' }));
+    reconnectTarget = Date.now() + reconnectDelay;
+    reconnectTimer = setTimeout(_connect, reconnectDelay);
+    reconnectDelay = Math.min(reconnectDelay * 2, 10000);
+  };
+
+  ws.onerror = () => ws.close();
+}

package/server/apiRouter.js

@@ -0,0 +1,321 @@
+// apiRouter.js — Express router for all API endpoints (no SQLite/database dependencies)
+import { Router } from 'express';
+import { findClaudeProcess, killSession, archiveSession, setSessionTitle, setSessionLabel, setSummary, getSession, detectSessionSource, createTerminalSession, deleteSessionFromMemory } from './sessionStore.js';
+import { createTerminal, closeTerminal, getTerminals, listSshKeys, listTmuxSessions } from './sshManager.js';
+import { getStats as getHookStats, resetStats as resetHookStats } from './hookStats.js';
+import { getMqStats } from './mqReader.js';
+import { execFile } from 'child_process';
+import { readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const __apiDirname = dirname(fileURLToPath(import.meta.url));
+
+const router = Router();
+
+// Hook performance stats
+router.get('/hook-stats', (req, res) => {
+  res.json(getHookStats());
+});
+
+router.post('/hook-stats/reset', (req, res) => {
+  resetHookStats();
+  res.json({ ok: true });
+});
+
+// Full reset — broadcast to all connected browsers to clear their IndexedDB
+router.post('/reset', async (req, res) => {
+  const { broadcast } = await import('./wsManager.js');
+  broadcast({ type: 'clearBrowserDb' });
+  res.json({ ok: true, message: 'Browser DB clear signal sent' });
+});
+
+// MQ reader stats
+router.get('/mq-stats', (req, res) => {
+  res.json(getMqStats());
+});
+
+// ---- Hook Density Management ----
+
+const CLAUDE_SETTINGS_PATH = join(homedir(), '.claude', 'settings.json');
+const INSTALL_HOOKS_SCRIPT = join(__apiDirname, '..', 'hooks', 'install-hooks.js');
+const HOOK_PATTERN = 'dashboard-hook.';
+const ALL_HOOK_EVENTS = [
+  'SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure',
+  'PermissionRequest', 'Stop', 'Notification', 'SubagentStart', 'SubagentStop',
+  'TeammateIdle', 'TaskCompleted', 'PreCompact', 'SessionEnd'
+];
+const DENSITY_EVENTS = {
+  high: ALL_HOOK_EVENTS,
+  medium: [
+    'SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure',
+    'PermissionRequest', 'Stop', 'Notification', 'SubagentStart', 'SubagentStop',
+    'TaskCompleted', 'SessionEnd'
+  ],
+  low: ['SessionStart', 'UserPromptSubmit', 'PermissionRequest', 'Stop', 'SessionEnd']
+};
+
+// Get current hooks status from ~/.claude/settings.json
+router.get('/hooks/status', (req, res) => {
+  try {
+    let claudeSettings = {};
+    try {
+      claudeSettings = JSON.parse(readFileSync(CLAUDE_SETTINGS_PATH, 'utf8'));
+    } catch { /* file doesn't exist yet */ }
+
+    const hooks = claudeSettings.hooks || {};
+    const installedEvents = ALL_HOOK_EVENTS.filter(event =>
+      hooks[event]?.some(group => group.hooks?.some(h => h.command?.includes(HOOK_PATTERN)))
+    );
+
+    // Infer density from installed events
+    let density = 'off';
+    if (installedEvents.length > 0) {
+      if (installedEvents.length === DENSITY_EVENTS.high.length &&
+          DENSITY_EVENTS.high.every(e => installedEvents.includes(e))) {
+        density = 'high';
+      } else if (installedEvents.length === DENSITY_EVENTS.medium.length &&
+                 DENSITY_EVENTS.medium.every(e => installedEvents.includes(e))) {
+        density = 'medium';
+      } else if (installedEvents.length === DENSITY_EVENTS.low.length &&
+                 DENSITY_EVENTS.low.every(e => installedEvents.includes(e))) {
+        density = 'low';
+      } else {
+        density = 'custom';
+      }
+    }
+
+    res.json({ installed: installedEvents.length > 0, density, events: installedEvents });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// Install hooks with specified density
+router.post('/hooks/install', (req, res) => {
+  const { density } = req.body;
+  if (!density || !DENSITY_EVENTS[density]) {
+    return res.status(400).json({ error: 'density must be one of: high, medium, low' });
+  }
+
+  // Run install-hooks.js with --density flag
+  execFile('node', [INSTALL_HOOKS_SCRIPT, '--density', density], { timeout: 15000 }, (err, stdout, stderr) => {
+    if (err) {
+      console.error('[hooks/install] Error:', err.message);
+      return res.status(500).json({ error: err.message, stdout, stderr });
+    }
+    console.log('[hooks/install]', stdout);
+    res.json({ ok: true, density, events: DENSITY_EVENTS[density], output: stdout });
+  });
+});
+
+// Uninstall all dashboard hooks
+router.post('/hooks/uninstall', (req, res) => {
+  // Run install-hooks.js with --uninstall flag
+  execFile('node', [INSTALL_HOOKS_SCRIPT, '--uninstall'], { timeout: 15000 }, (err, stdout, stderr) => {
+    if (err) {
+      console.error('[hooks/uninstall] Error:', err.message);
+      return res.status(500).json({ error: err.message, stdout, stderr });
+    }
+    console.log('[hooks/uninstall]', stdout);
+    res.json({ ok: true, output: stdout });
+  });
+});
+
+// ---- Session Control Endpoints ----
+
+// Kill session process — sends SIGTERM, then SIGKILL after 3s if still alive
+router.post('/sessions/:id/kill', (req, res) => {
+  if (!req.body.confirm) {
+    return res.status(400).json({ error: 'Must send {confirm: true} to kill a session' });
+  }
+  const sessionId = req.params.id;
+  const mem = getSession(sessionId);
+  const pid = findClaudeProcess(sessionId, mem?.projectPath);
+  const source = detectSessionSource(sessionId);
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM');
+      // Follow up with SIGKILL after 3s if process is still alive
+      setTimeout(() => {
+        try {
+          process.kill(pid, 0); // Check if still alive
+          process.kill(pid, 'SIGKILL');
+        } catch(e) { /* already dead — good */ }
+      }, 3000);
+    } catch (e) {
+      return res.status(500).json({ error: `Failed to kill PID ${pid}: ${e.message}` });
+    }
+  }
+  const session = killSession(sessionId);
+  archiveSession(sessionId, true);
+  // Close associated SSH terminal if present
+  if (session && session.terminalId) {
+    closeTerminal(session.terminalId);
+  } else if (mem && mem.terminalId) {
+    closeTerminal(mem.terminalId);
+  }
+  if (!session && !pid) {
+    return res.status(404).json({ error: 'Session not found and no matching process' });
+  }
+  res.json({ ok: true, pid: pid || null, source });
+});
+
+// Permanently delete a session — removes from memory, broadcasts removal to clients
+router.delete('/sessions/:id', async (req, res) => {
+  const sessionId = req.params.id;
+  const session = getSession(sessionId);
+  // Close terminal if still active
+  if (session && session.terminalId) {
+    closeTerminal(session.terminalId);
+  }
+  const removed = deleteSessionFromMemory(sessionId);
+  // Broadcast session_removed so all connected browsers remove the card
+  try {
+    const { broadcast } = await import('./wsManager.js');
+    broadcast({ type: 'session_removed', sessionId });
+  } catch (e) {}
+  res.json({ ok: true, removed });
+});
+
+// Detect session source (vscode / terminal)
+router.get('/sessions/:id/source', (req, res) => {
+  const source = detectSessionSource(req.params.id);
+  res.json({ source });
+});
+
+
+
+// Update session title (in-memory only, no DB write)
+router.put('/sessions/:id/title', (req, res) => {
+  const { title } = req.body;
+  if (title === undefined) return res.status(400).json({ error: 'title is required' });
+  setSessionTitle(req.params.id, title);
+  res.json({ ok: true });
+});
+
+// Update session label (in-memory only, no DB write)
+router.put('/sessions/:id/label', (req, res) => {
+  const { label } = req.body;
+  if (label === undefined) return res.status(400).json({ error: 'label is required' });
+  setSessionLabel(req.params.id, label);
+  res.json({ ok: true });
+});
+
+// Summarize session using Claude CLI
+// The frontend sends { context, promptTemplate } from IndexedDB data.
+// If custom_prompt is provided, use it directly as the prompt template.
+router.post('/sessions/:id/summarize', async (req, res) => {
+  const sessionId = req.params.id;
+  const { context, promptTemplate: bodyPromptTemplate, custom_prompt: customPrompt } = req.body;
+
+  if (!context) {
+    return res.status(400).json({ error: 'context is required in request body (prepared from IndexedDB data)' });
+  }
+
+  // Determine prompt template: custom_prompt > bodyPromptTemplate > default
+  const promptTemplate = customPrompt || bodyPromptTemplate || 'Summarize this Claude Code session in detail.';
+
+  const summaryPrompt = `${promptTemplate}\n\n--- SESSION TRANSCRIPT ---\n${context}`;
+
+  try {
+    const summary = await new Promise((resolve, reject) => {
+      const child = execFile('claude', ['-p', '--model', 'haiku'], {
+        timeout: 60000,
+        maxBuffer: 1024 * 1024,
+      }, (error, stdout, stderr) => {
+        if (error) return reject(error);
+        resolve(stdout.trim());
+      });
+      child.stdin.write(summaryPrompt);
+      child.stdin.end();
+    });
+
+    // Store summary in memory
+    setSummary(sessionId, summary);
+    archiveSession(sessionId, true);
+
+    res.json({ ok: true, summary });
+  } catch (err) {
+    console.error('[apiRouter] Summarize error:', err.message);
+    res.status(500).json({ error: `Summarize failed: ${err.message}` });
+  }
+});
+
+// ── SSH Keys ──
+
+router.get('/ssh-keys', (req, res) => {
+  res.json({ keys: listSshKeys() });
+});
+
+// ── Tmux Sessions ──
+
+router.post('/tmux-sessions', async (req, res) => {
+  try {
+    const { host, port, username, password, privateKeyPath, authMethod, passphrase } = req.body;
+    if (!username) return res.status(400).json({ error: 'username required' });
+    const config = {
+      host: host || 'localhost',
+      port: port || 22,
+      username,
+      authMethod: authMethod || 'key',
+      privateKeyPath,
+      password,
+      passphrase,
+    };
+    const sessions = await listTmuxSessions(config);
+    res.json({ sessions });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── Terminals ──
+
+router.post('/terminals', async (req, res) => {
+  try {
+    const { host, port, username, password, privateKeyPath, authMethod, workingDir, command, apiKey, tmuxSession, useTmux, sessionTitle, label } = req.body;
+
+    if (!username) return res.status(400).json({ error: 'username required' });
+    const config = {
+      host: host || 'localhost',
+      port: port || 22,
+      username,
+      authMethod: authMethod || 'key',
+      privateKeyPath,
+      workingDir: workingDir || '~',
+      command: command || 'claude',
+      password,
+    };
+
+    // Tmux modes
+    if (tmuxSession) config.tmuxSession = tmuxSession; // attach to existing
+    if (useTmux) config.useTmux = true; // wrap in new tmux session
+    if (sessionTitle) config.sessionTitle = sessionTitle;
+    if (label) config.label = label;
+
+    // Resolve API key from request body only (no DB lookup)
+    if (apiKey) {
+      config.apiKey = apiKey;
+    }
+
+    const terminalId = await createTerminal(config, null);
+    // Create session card immediately so it appears in the dashboard
+    await createTerminalSession(terminalId, config);
+    res.json({ ok: true, terminalId });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+router.get('/terminals', (req, res) => {
+  res.json({ terminals: getTerminals() });
+});
+
+router.delete('/terminals/:id', (req, res) => {
+  closeTerminal(req.params.id);
+  res.json({ ok: true });
+});
+
+export default router;

package/server/config.js

@@ -0,0 +1,120 @@
+// config.js — Extracted session status & approval detection configuration
+import { config as serverConfig } from './serverConfig.js';
+
+// ---- Tool Categories for Approval Detection ----
+// When PreToolUse fires, we start a timer. If PostToolUse doesn't arrive
+// within the timeout, the tool is likely pending user interaction.
+// NOTE: PermissionRequest event (when available at medium+ density) provides
+// a direct signal for approval-needed state, replacing the timeout heuristic.
+
+export const TOOL_CATEGORIES = {
+  // Tools that complete instantly when auto-approved (3s timeout)
+  fast: ['Read', 'Write', 'Edit', 'Grep', 'Glob', 'NotebookEdit'],
+  // Tools that ALWAYS require user interaction — not approval, but input (3s timeout)
+  userInput: ['AskUserQuestion', 'EnterPlanMode', 'ExitPlanMode'],
+  // Tools that can be slow but not minutes-slow (15s timeout)
+  medium: ['WebFetch', 'WebSearch'],
+  // Tools that can run for minutes but still need approval detection (8s timeout).
+  // Tradeoff: auto-approved long-running commands (npm install, builds) will
+  // briefly show as "approval" after 8s until PostToolUse clears it.
+  slow: ['Bash', 'Task'],
+};
+
+export const TOOL_TIMEOUTS = {
+  fast: 3000,
+  userInput: 3000,
+  medium: 15000,
+  slow: 8000,
+};
+
+// Status to set when each category's timeout fires
+export const WAITING_REASONS = {
+  fast: 'approval',     // "NEEDS YOUR APPROVAL"
+  userInput: 'input',   // "WAITING FOR YOUR ANSWER"
+  medium: 'approval',   // "NEEDS YOUR APPROVAL"
+  slow: 'approval',     // "NEEDS YOUR APPROVAL"
+};
+
+// Human-readable labels for waitingDetail per category
+export const WAITING_LABELS = {
+  approval: (toolName, detail) =>
+    detail ? `Approve ${toolName}: ${detail}` : `Approve ${toolName}`,
+  input: (toolName, _detail) => {
+    if (toolName === 'AskUserQuestion') return 'Waiting for your answer';
+    if (toolName === 'EnterPlanMode') return 'Review plan mode request';
+    if (toolName === 'ExitPlanMode') return 'Review plan';
+    return `Waiting for input on ${toolName}`;
+  },
+};
+
+// ---- Auto-Idle Timeouts ----
+// Sessions transition to idle/waiting if no activity for these durations (ms)
+export const AUTO_IDLE_TIMEOUTS = {
+  prompting: 30_000,    // prompting → waiting (user likely cancelled)
+  waiting: 120_000,     // waiting → idle (2 min)
+  working: 180_000,     // working → idle (3 min)
+  approval: 600_000,    // approval → idle (10 min safety net)
+  input: 600_000,       // input → idle (10 min safety net)
+};
+
+// ---- Process Liveness Check ----
+// How often to check if session PIDs are still alive (ms).
+// When a user closes VS Code, JetBrains, or terminal abruptly, the SessionEnd
+// hook never fires. This monitor detects dead processes and auto-ends sessions.
+export const PROCESS_CHECK_INTERVAL = serverConfig.processCheckInterval || 15_000;
+
+// ---- Animation State Mappings ----
+export const STATUS_ANIMATIONS = {
+  idle:      { animationState: 'Idle',    emote: null },
+  prompting: { animationState: 'Walking', emote: 'Wave' },
+  working:   { animationState: 'Running', emote: null },
+  approval:  { animationState: 'Waiting', emote: null },
+  input:     { animationState: 'Waiting', emote: null },
+  waiting:   { animationState: 'Waiting', emote: 'ThumbsUp' },
+  ended:     { animationState: 'Death',   emote: null },
+};
+
+// ---- Precomputed Tool → Category Lookup ----
+// Built once at import time for O(1) lookups in hot path
+const _toolToCategory = new Map();
+for (const [category, tools] of Object.entries(TOOL_CATEGORIES)) {
+  for (const tool of tools) {
+    _toolToCategory.set(tool, category);
+  }
+}
+
+/**
+ * Get the category for a tool name.
+ * @returns {string|null} 'fast' | 'userInput' | 'medium' | 'slow' | null (no timeout)
+ */
+export function getToolCategory(toolName) {
+  return _toolToCategory.get(toolName) || null;
+}
+
+/**
+ * Get the approval/input timeout for a tool, or 0 if no detection applies.
+ */
+export function getToolTimeout(toolName) {
+  const cat = getToolCategory(toolName);
+  return cat ? (TOOL_TIMEOUTS[cat] || 0) : 0;
+}
+
+/**
+ * Get the waiting status to set when a tool's timeout fires.
+ * @returns {'approval'|'input'|null}
+ */
+export function getWaitingStatus(toolName) {
+  const cat = getToolCategory(toolName);
+  return cat ? (WAITING_REASONS[cat] || null) : null;
+}
+
+/**
+ * Get the human-readable waitingDetail label for a tool.
+ */
+export function getWaitingLabel(toolName, detail) {
+  const cat = getToolCategory(toolName);
+  if (!cat) return null;
+  const status = WAITING_REASONS[cat];
+  const labelFn = WAITING_LABELS[status];
+  return labelFn ? labelFn(toolName, detail) : null;
+}

package/server/hookProcessor.js

@@ -0,0 +1,55 @@
+// hookProcessor.js — Shared hook event processing pipeline
+// Used by both hookRouter.js (HTTP) and mqReader.js (file-based MQ)
+import { handleEvent } from './sessionStore.js';
+import { broadcast } from './wsManager.js';
+import { recordHook, getStats } from './hookStats.js';
+import log from './logger.js';
+
+/**
+ * Process a hook event from any transport (HTTP or MQ).
+ * Validates, calls handleEvent(), records stats, broadcasts to WebSocket clients.
+ *
+ * @param {object} hookData - Parsed hook JSON payload
+ * @param {'http'|'mq'} [source='http'] - Transport source for logging
+ * @returns {object|null} Session delta if event was processed, null otherwise
+ */
+export function processHookEvent(hookData, source = 'http') {
+  const receivedAt = Date.now();
+
+  if (!hookData || !hookData.session_id) {
+    log.warn('hook', `Received hook without session_id (via ${source})`);
+    return null;
+  }
+
+  log.debug('hook', `Event: ${hookData.hook_event_name || 'unknown'} session=${hookData.session_id} via=${source}`);
+  log.debugJson('hook', 'Hook payload', hookData);
+
+  // Measure server processing time
+  const processStart = Date.now();
+  const delta = handleEvent(hookData);
+  const processingTime = Date.now() - processStart;
+
+  // Calculate delivery latency (hook_sent_at is seconds * 1000 from bash `date +%s`)
+  let deliveryLatency = null;
+  if (hookData.hook_sent_at) {
+    deliveryLatency = receivedAt - hookData.hook_sent_at;
+    if (deliveryLatency < 0) deliveryLatency = 0;
+  }
+
+  // Record stats
+  const eventType = hookData.hook_event_name || 'unknown';
+  recordHook(eventType, deliveryLatency, processingTime);
+
+  // Broadcast to WebSocket clients
+  if (delta) {
+    log.debug('hook', `Broadcasting session_update for ${hookData.session_id} status=${delta.session?.status}`);
+    broadcast({ type: 'session_update', ...delta });
+    if (delta.team) {
+      log.debug('hook', `Broadcasting team_update for team=${delta.team.teamId}`);
+      broadcast({ type: 'team_update', team: delta.team });
+    }
+    broadcast({ type: 'hook_stats', stats: getStats() });
+  }
+
+  return delta;
+}

package/server/hookRouter.js

@@ -0,0 +1,18 @@
+// hookRouter.js — POST /api/hooks endpoint (HTTP transport adapter)
+import { Router } from 'express';
+import { processHookEvent } from './hookProcessor.js';
+import log from './logger.js';
+
+const router = Router();
+
+router.post('/', (req, res) => {
+  const hookData = req.body;
+  if (!hookData || !hookData.session_id) {
+    log.warn('hook', 'Received hook without session_id');
+    return res.status(400).json({ error: 'Missing session_id' });
+  }
+  processHookEvent(hookData, 'http');
+  res.json({ ok: true });
+});
+
+export default router;