ai-agent-session-center 2.0.2 → 2.0.3

package/server/approvalDetector.ts

@@ -0,0 +1,94 @@
+/**
+ * @module approvalDetector
+ * Detects when a tool call is pending user approval by starting category-based timers.
+ * If PostToolUse does not arrive within the timeout, the session transitions to approval/input status.
+ * PermissionRequest events provide a direct signal that bypasses the timeout heuristic.
+ */
+import { execSync } from 'child_process';
+import { getToolTimeout, getToolCategory, getWaitingStatus, getWaitingLabel } from './config.js';
+import { SESSION_STATUS, ANIMATION_STATE } from './constants.js';
+import log from './logger.js';
+import type { Session } from '../src/types/session.js';
+
+/**
+ * Validate PID as a positive integer.
+ */
+function validatePid(pid: unknown): number | null {
+  const n = parseInt(String(pid), 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
+/** session_id -> timeout for tool approval detection */
+const pendingToolTimers = new Map<string, ReturnType<typeof setTimeout>>();
+
+/**
+ * Check if a PID has any child processes (i.e. a command is running).
+ */
+export function hasChildProcesses(pid: number): boolean {
+  const validPid = validatePid(pid);
+  if (!validPid) return false;
+  try {
+    const out = execSync(`pgrep -P ${validPid} 2>/dev/null`, { encoding: 'utf-8', timeout: 2000 });
+    return out.trim().length > 0;
+  } catch (e: unknown) {
+    log.debug('session', `hasChildProcesses check failed for pid=${validPid}: ${(e as Error).message}`);
+    return false;
+  }
+}
+
+/**
+ * Start an approval detection timer for a tool invocation.
+ * If PostToolUse doesn't arrive within the timeout, transitions session to approval/input.
+ */
+export function startApprovalTimer(
+  sessionId: string,
+  session: Session,
+  toolName: string,
+  toolInputSummary: string,
+  broadcastFn: (session: Session) => Promise<void>,
+): void {
+  clearTimeout(pendingToolTimers.get(sessionId));
+
+  const approvalTimeout = getToolTimeout(toolName);
+  if (approvalTimeout > 0) {
+    session.pendingTool = toolName;
+    session.pendingToolDetail = toolInputSummary;
+    const timer = setTimeout(async () => {
+      pendingToolTimers.delete(sessionId);
+      if (session.status === SESSION_STATUS.WORKING && session.pendingTool) {
+        const category = getToolCategory(session.pendingTool);
+        if (category === 'slow' && session.cachedPid && hasChildProcesses(session.cachedPid)) {
+          return; // Command is running, not waiting for approval
+        }
+
+        const waitingStatus = getWaitingStatus(session.pendingTool) || SESSION_STATUS.APPROVAL;
+        (session as Session).status = waitingStatus as Session['status'];
+        session.animationState = ANIMATION_STATE.WAITING;
+        session.waitingDetail = getWaitingLabel(session.pendingTool, session.pendingToolDetail || '');
+        try {
+          await broadcastFn(session);
+        } catch (e: unknown) {
+          log.warn('session', `Approval broadcast failed: ${(e as Error).message}`);
+        }
+      }
+    }, approvalTimeout);
+    pendingToolTimers.set(sessionId, timer);
+  } else {
+    session.pendingTool = null;
+    session.pendingToolDetail = null;
+  }
+}
+
+/**
+ * Clear a pending approval timer for a session.
+ * Also resets the pending tool and waiting detail on the session.
+ */
+export function clearApprovalTimer(sessionId: string, session: Session | null): void {
+  clearTimeout(pendingToolTimers.get(sessionId));
+  pendingToolTimers.delete(sessionId);
+  if (session) {
+    session.pendingTool = null;
+    session.pendingToolDetail = null;
+    session.waitingDetail = null;
+  }
+}

package/server/authManager.ts

@@ -0,0 +1,144 @@
+// authManager.ts — Password authentication with scrypt hashing and token sessions
+import { scryptSync, randomBytes, timingSafeEqual } from 'crypto';
+import { config } from './serverConfig.js';
+import log from './logger.js';
+import type { IncomingMessage } from 'http';
+import type { Request, Response, NextFunction } from 'express';
+
+const TOKEN_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const SCRYPT_KEYLEN = 64;
+
+// In-memory token store: Map<token, { createdAt: number }>
+const tokens = new Map<string, { createdAt: number }>();
+
+/**
+ * Hash a plaintext password with a random salt.
+ * @returns "salt:hash" (both hex-encoded)
+ */
+export function hashPassword(password: string): string {
+  const salt = randomBytes(16).toString('hex');
+  const hash = scryptSync(password, salt, SCRYPT_KEYLEN).toString('hex');
+  return `${salt}:${hash}`;
+}
+
+/**
+ * Verify a plaintext password against a stored "salt:hash" string.
+ * Uses timing-safe comparison to prevent timing attacks.
+ */
+export function verifyPassword(password: string, stored: string): boolean {
+  if (!stored || !stored.includes(':')) return false;
+  const [salt, storedHash] = stored.split(':');
+  const derived = scryptSync(password, salt, SCRYPT_KEYLEN).toString('hex');
+  if (derived.length !== storedHash.length) return false;
+  return timingSafeEqual(Buffer.from(derived, 'hex'), Buffer.from(storedHash, 'hex'));
+}
+
+/**
+ * Create a new auth token with 24h TTL.
+ */
+export function createToken(): string {
+  const token = randomBytes(32).toString('hex');
+  tokens.set(token, { createdAt: Date.now() });
+  return token;
+}
+
+/**
+ * Validate a token exists and has not expired.
+ * Expired tokens are removed on check.
+ */
+export function validateToken(token: string | null): boolean {
+  if (!token) return false;
+  const entry = tokens.get(token);
+  if (!entry) return false;
+  if (Date.now() - entry.createdAt > TOKEN_TTL_MS) {
+    tokens.delete(token);
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Remove a token (logout).
+ */
+export function removeToken(token: string): void {
+  if (token) tokens.delete(token);
+}
+
+/**
+ * Check if password authentication is enabled.
+ */
+export function isPasswordEnabled(): boolean {
+  return Boolean(config.passwordHash);
+}
+
+/**
+ * Parse the auth_token cookie from a raw Cookie header string.
+ */
+export function parseCookieToken(cookieHeader: string | undefined): string | null {
+  if (!cookieHeader) return null;
+  const match = cookieHeader.match(/(?:^|;\s*)auth_token=([^;]+)/);
+  return match ? match[1] : null;
+}
+
+/**
+ * Extract token from request: cookie, Authorization header, or query string.
+ */
+export function extractToken(req: IncomingMessage): string | null {
+  // 1. Cookie
+  const cookieToken = parseCookieToken(req.headers.cookie);
+  if (cookieToken) return cookieToken;
+  // 2. Authorization: Bearer <token>
+  const authHeader = req.headers.authorization;
+  if (authHeader && authHeader.startsWith('Bearer ')) return authHeader.slice(7);
+  // 3. Query string (?token=xxx) — used by WebSocket
+  if (req.url && req.url.includes('token=')) {
+    try {
+      const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+      return url.searchParams.get('token');
+    } catch { /* ignore parse errors */ }
+  }
+  return null;
+}
+
+/**
+ * Express middleware: protect routes that require authentication.
+ * Checks cookie, Authorization header, and query string.
+ * Skips auth check if password is not enabled.
+ */
+export function authMiddleware(req: Request, res: Response, next: NextFunction): void {
+  if (!isPasswordEnabled()) {
+    next();
+    return;
+  }
+  const token = extractToken(req);
+  if (validateToken(token)) {
+    next();
+    return;
+  }
+  log.debug('auth', `Unauthorized request: ${req.method} ${req.originalUrl}`);
+  res.status(401).json({ error: 'Unauthorized' });
+}
+
+/**
+ * Periodic cleanup of expired tokens (runs every hour).
+ */
+let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+export function startTokenCleanup(): void {
+  if (cleanupTimer) return;
+  cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [token, entry] of tokens) {
+      if (now - entry.createdAt > TOKEN_TTL_MS) {
+        tokens.delete(token);
+      }
+    }
+  }, 60 * 60 * 1000);
+}
+
+export function stopTokenCleanup(): void {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer);
+    cleanupTimer = null;
+  }
+}

package/server/autoIdleManager.ts

@@ -0,0 +1,110 @@
+/**
+ * @module autoIdleManager
+ * Transitions sessions to idle/waiting after configurable inactivity timeouts.
+ * Prevents sessions from being stuck in transient states (prompting, working, approval)
+ * when hooks are missed or the user abandons the session. Also cleans up stale pendingResume entries.
+ */
+import { AUTO_IDLE_TIMEOUTS } from './config.js';
+import { SESSION_STATUS, ANIMATION_STATE, WS_TYPES } from './constants.js';
+import log from './logger.js';
+import type { Session, PendingResume } from '../src/types/session.js';
+import type { ServerMessage } from '../src/types/websocket.js';
+
+let idleInterval: ReturnType<typeof setInterval> | null = null;
+let pendingResumeCleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+/**
+ * Start the auto-idle check interval.
+ * Transitions sessions to idle/waiting if no activity for configured durations.
+ */
+export function startAutoIdle(sessions: Map<string, Session>): void {
+  if (idleInterval) return;
+
+  idleInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [_id, session] of sessions) {
+      if (session.status === SESSION_STATUS.ENDED || session.status === SESSION_STATUS.IDLE) continue;
+      const elapsed = now - session.lastActivityAt;
+
+      if (session.status === SESSION_STATUS.APPROVAL && elapsed > AUTO_IDLE_TIMEOUTS.approval) {
+        session.status = SESSION_STATUS.IDLE;
+        session.animationState = ANIMATION_STATE.IDLE;
+        session.emote = null;
+        session.pendingTool = null;
+        session.pendingToolDetail = null;
+        session.waitingDetail = null;
+      } else if (session.status === SESSION_STATUS.INPUT && elapsed > AUTO_IDLE_TIMEOUTS.input) {
+        session.status = SESSION_STATUS.IDLE;
+        session.animationState = ANIMATION_STATE.IDLE;
+        session.emote = null;
+        session.pendingTool = null;
+        session.pendingToolDetail = null;
+        session.waitingDetail = null;
+      } else if (session.status === SESSION_STATUS.PROMPTING && elapsed > AUTO_IDLE_TIMEOUTS.prompting) {
+        session.status = SESSION_STATUS.WAITING;
+        session.animationState = ANIMATION_STATE.WAITING;
+        session.emote = null;
+      } else if (session.status === SESSION_STATUS.WAITING && elapsed > AUTO_IDLE_TIMEOUTS.waiting) {
+        session.status = SESSION_STATUS.IDLE;
+        session.animationState = ANIMATION_STATE.IDLE;
+        session.emote = null;
+      } else if (session.status !== SESSION_STATUS.WAITING && session.status !== SESSION_STATUS.PROMPTING
+        && session.status !== SESSION_STATUS.APPROVAL && session.status !== SESSION_STATUS.INPUT
+        && session.status !== SESSION_STATUS.CONNECTING
+        && elapsed > AUTO_IDLE_TIMEOUTS.working) {
+        session.status = SESSION_STATUS.IDLE;
+        session.animationState = ANIMATION_STATE.IDLE;
+        session.emote = null;
+      }
+    }
+  }, 10000);
+}
+
+/**
+ * Stop the auto-idle check interval.
+ */
+export function stopAutoIdle(): void {
+  if (idleInterval) {
+    clearInterval(idleInterval);
+    idleInterval = null;
+  }
+}
+
+/**
+ * Start cleaning up stale pendingResume entries.
+ */
+export function startPendingResumeCleanup(
+  pendingResume: Map<string, PendingResume>,
+  sessions: Map<string, Session>,
+  broadcastFn: (data: ServerMessage) => Promise<void>,
+): void {
+  if (pendingResumeCleanupInterval) return;
+
+  pendingResumeCleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [termId, pending] of pendingResume) {
+      if (now - pending.timestamp > 120000) { // 2 minutes
+        pendingResume.delete(termId);
+        const session = sessions.get(pending.oldSessionId);
+        if (session && session.status === SESSION_STATUS.CONNECTING) {
+          session.status = SESSION_STATUS.ENDED;
+          session.animationState = ANIMATION_STATE.DEATH;
+          session.isHistorical = true;
+          session.terminalId = null;
+          log.info('session', `RESUME TIMEOUT: reverted session ${pending.oldSessionId?.slice(0, 8)} back to ended`);
+          broadcastFn({ type: WS_TYPES.SESSION_UPDATE, session: { ...session } }).catch(() => {});
+        }
+      }
+    }
+  }, 30000);
+}
+
+/**
+ * Stop the pending resume cleanup interval.
+ */
+export function stopPendingResumeCleanup(): void {
+  if (pendingResumeCleanupInterval) {
+    clearInterval(pendingResumeCleanupInterval);
+    pendingResumeCleanupInterval = null;
+  }
+}

package/server/config.ts

@@ -0,0 +1,121 @@
+// config.ts — Extracted session status & approval detection configuration
+import { config as serverConfig } from './serverConfig.js';
+import type { ToolCategory } from '../src/types/settings.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: Record<ToolCategory, string[]> = {
+  // 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: Record<ToolCategory, number> = {
+  fast: 3000,
+  userInput: 3000,
+  medium: 15000,
+  slow: 8000,
+};
+
+// Status to set when each category's timeout fires
+export const WAITING_REASONS: Record<ToolCategory, string> = {
+  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: Record<string, (toolName: string, detail: string) => string> = {
+  approval: (toolName: string, detail: string) =>
+    detail ? `Approve ${toolName}: ${detail}` : `Approve ${toolName}`,
+  input: (toolName: string, _detail: string) => {
+    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: Record<string, number> = {
+  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: number = serverConfig.processCheckInterval || 15_000;
+
+// ---- Animation State Mappings ----
+export const STATUS_ANIMATIONS: Record<string, { animationState: string; emote: string | null }> = {
+  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<string, ToolCategory>();
+for (const [category, tools] of Object.entries(TOOL_CATEGORIES)) {
+  for (const tool of tools) {
+    _toolToCategory.set(tool, category as ToolCategory);
+  }
+}
+
+/**
+ * Get the category for a tool name.
+ * @returns 'fast' | 'userInput' | 'medium' | 'slow' | null (no timeout)
+ */
+export function getToolCategory(toolName: string): ToolCategory | null {
+  return _toolToCategory.get(toolName) || null;
+}
+
+/**
+ * Get the approval/input timeout for a tool, or 0 if no detection applies.
+ */
+export function getToolTimeout(toolName: string): number {
+  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: string): string | null {
+  const cat = getToolCategory(toolName);
+  return cat ? (WAITING_REASONS[cat] || null) : null;
+}
+
+/**
+ * Get the human-readable waitingDetail label for a tool.
+ */
+export function getWaitingLabel(toolName: string, detail: string): string | null {
+  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/constants.ts

@@ -0,0 +1,150 @@
+/**
+ * @module constants
+ * Centralized magic strings for event types, session statuses, animation states,
+ * and WebSocket message types. Shared by all server modules to eliminate string duplication.
+ */
+
+// Hook event types (Claude Code lifecycle events)
+export const EVENT_TYPES = {
+  SESSION_START: 'SessionStart',
+  SESSION_END: 'SessionEnd',
+  USER_PROMPT_SUBMIT: 'UserPromptSubmit',
+  PRE_TOOL_USE: 'PreToolUse',
+  POST_TOOL_USE: 'PostToolUse',
+  POST_TOOL_USE_FAILURE: 'PostToolUseFailure',
+  PERMISSION_REQUEST: 'PermissionRequest',
+  STOP: 'Stop',
+  SUBAGENT_START: 'SubagentStart',
+  SUBAGENT_STOP: 'SubagentStop',
+  TEAMMATE_IDLE: 'TeammateIdle',
+  TASK_COMPLETED: 'TaskCompleted',
+  PRE_COMPACT: 'PreCompact',
+  NOTIFICATION: 'Notification',
+  // Gemini events
+  BEFORE_AGENT: 'BeforeAgent',
+  BEFORE_TOOL: 'BeforeTool',
+  AFTER_TOOL: 'AfterTool',
+  AFTER_AGENT: 'AfterAgent',
+  // Codex events
+  AGENT_TURN_COMPLETE: 'agent-turn-complete',
+} as const;
+
+// All Claude hook events (used for hook density configuration)
+export const ALL_CLAUDE_HOOK_EVENTS: string[] = [
+  EVENT_TYPES.SESSION_START,
+  EVENT_TYPES.USER_PROMPT_SUBMIT,
+  EVENT_TYPES.PRE_TOOL_USE,
+  EVENT_TYPES.POST_TOOL_USE,
+  EVENT_TYPES.POST_TOOL_USE_FAILURE,
+  EVENT_TYPES.PERMISSION_REQUEST,
+  EVENT_TYPES.STOP,
+  EVENT_TYPES.NOTIFICATION,
+  EVENT_TYPES.SUBAGENT_START,
+  EVENT_TYPES.SUBAGENT_STOP,
+  EVENT_TYPES.TEAMMATE_IDLE,
+  EVENT_TYPES.TASK_COMPLETED,
+  EVENT_TYPES.PRE_COMPACT,
+  EVENT_TYPES.SESSION_END,
+];
+
+// Known event types set (all transports — Claude, Gemini, Codex)
+export const KNOWN_EVENTS: Set<string> = new Set([
+  ...ALL_CLAUDE_HOOK_EVENTS,
+  EVENT_TYPES.BEFORE_AGENT,
+  EVENT_TYPES.BEFORE_TOOL,
+  EVENT_TYPES.AFTER_TOOL,
+  EVENT_TYPES.AFTER_AGENT,
+  EVENT_TYPES.AGENT_TURN_COMPLETE,
+]);
+
+// Hook density presets — which events to register at each density level
+export const DENSITY_EVENTS: Record<string, string[]> = {
+  high: ALL_CLAUDE_HOOK_EVENTS,
+  medium: [
+    EVENT_TYPES.SESSION_START,
+    EVENT_TYPES.USER_PROMPT_SUBMIT,
+    EVENT_TYPES.PRE_TOOL_USE,
+    EVENT_TYPES.POST_TOOL_USE,
+    EVENT_TYPES.POST_TOOL_USE_FAILURE,
+    EVENT_TYPES.PERMISSION_REQUEST,
+    EVENT_TYPES.STOP,
+    EVENT_TYPES.NOTIFICATION,
+    EVENT_TYPES.SUBAGENT_START,
+    EVENT_TYPES.SUBAGENT_STOP,
+    EVENT_TYPES.TASK_COMPLETED,
+    EVENT_TYPES.SESSION_END,
+  ],
+  low: [
+    EVENT_TYPES.SESSION_START,
+    EVENT_TYPES.USER_PROMPT_SUBMIT,
+    EVENT_TYPES.PERMISSION_REQUEST,
+    EVENT_TYPES.STOP,
+    EVENT_TYPES.SESSION_END,
+  ],
+};
+
+// Session statuses
+export const SESSION_STATUS = {
+  IDLE: 'idle',
+  PROMPTING: 'prompting',
+  WORKING: 'working',
+  APPROVAL: 'approval',
+  INPUT: 'input',
+  WAITING: 'waiting',
+  ENDED: 'ended',
+  CONNECTING: 'connecting',
+} as const;
+
+// Animation states
+export const ANIMATION_STATE = {
+  IDLE: 'Idle',
+  WALKING: 'Walking',
+  RUNNING: 'Running',
+  WAITING: 'Waiting',
+  DEATH: 'Death',
+  DANCE: 'Dance',
+} as const;
+
+// Emote names
+export const EMOTE = {
+  WAVE: 'Wave',
+  THUMBS_UP: 'ThumbsUp',
+  JUMP: 'Jump',
+  YES: 'Yes',
+} as const;
+
+// WebSocket message types
+export const WS_TYPES = {
+  SESSION_UPDATE: 'session_update',
+  SESSION_REMOVED: 'session_removed',
+  TEAM_UPDATE: 'team_update',
+  HOOK_STATS: 'hook_stats',
+  SNAPSHOT: 'snapshot',
+  TERMINAL_OUTPUT: 'terminal_output',
+  TERMINAL_READY: 'terminal_ready',
+  TERMINAL_CLOSED: 'terminal_closed',
+  TERMINAL_INPUT: 'terminal_input',
+  TERMINAL_RESIZE: 'terminal_resize',
+  TERMINAL_DISCONNECT: 'terminal_disconnect',
+  TERMINAL_SUBSCRIBE: 'terminal_subscribe',
+  UPDATE_QUEUE_COUNT: 'update_queue_count',
+  REPLAY: 'replay',
+  CLEAR_BROWSER_DB: 'clearBrowserDb',
+} as const;
+
+// Session sources
+export const SESSION_SOURCE = {
+  SSH: 'ssh',
+  VSCODE: 'vscode',
+  JETBRAINS: 'jetbrains',
+  ITERM: 'iterm',
+  WARP: 'warp',
+  KITTY: 'kitty',
+  GHOSTTY: 'ghostty',
+  ALACRITTY: 'alacritty',
+  WEZTERM: 'wezterm',
+  HYPER: 'hyper',
+  TERMINAL: 'terminal',
+  TMUX: 'tmux',
+  UNKNOWN: 'unknown',
+} as const;