claudehq 1.0.0 → 1.0.2

package/lib/sessions/manager.js

@@ -0,0 +1,870 @@
+/**
+ * Session Manager - Tracks and manages Claude Code sessions
+ *
+ * Handles session lifecycle, status tracking, health monitoring,
+ * permission detection, and tmux integration.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+
+const {
+  EVENTS_DIR,
+  CUSTOM_NAMES_FILE,
+  HIDDEN_SESSIONS_FILE,
+  SESSION_STATUS,
+  HEALTH_CHECK_INTERVAL,
+  WORKING_TIMEOUT
+} = require('../core/config');
+const { eventBus, EventTypes } = require('../core/event-bus');
+const { sseClients, broadcastUpdate } = require('../core/sse');
+
+// File paths
+const SESSIONS_FILE = path.join(EVENTS_DIR, 'sessions.json');
+
+// In-memory session storage
+const managedSessions = new Map();
+const claudeToManagedMap = new Map(); // Maps Claude session IDs to managed session IDs
+let sessionCounter = 0;
+
+// Permission tracking
+const pendingPermissions = new Map(); // sessionId -> { tool, detectedAt }
+
+// Callbacks for metadata enrichment (set by data modules)
+let getSessionMetadataCallback = null;
+
+// =============================================================================
+// Utility Functions
+// =============================================================================
+
+function shortId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+
+function validateTmuxSession(name) {
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error('Invalid tmux session name');
+  }
+  return name;
+}
+
+// =============================================================================
+// Session Storage
+// =============================================================================
+
+function loadManagedSessions() {
+  if (!fs.existsSync(SESSIONS_FILE)) {
+    console.log('  No saved sessions file found');
+    return;
+  }
+
+  try {
+    const content = fs.readFileSync(SESSIONS_FILE, 'utf-8');
+    const data = JSON.parse(content);
+
+    if (Array.isArray(data.sessions)) {
+      for (const session of data.sessions) {
+        session.status = SESSION_STATUS.OFFLINE;
+        session.currentTool = undefined;
+        managedSessions.set(session.id, session);
+      }
+    }
+
+    if (Array.isArray(data.claudeToManagedMap)) {
+      for (const [claudeId, managedId] of data.claudeToManagedMap) {
+        claudeToManagedMap.set(claudeId, managedId);
+      }
+    }
+
+    if (typeof data.sessionCounter === 'number') {
+      sessionCounter = data.sessionCounter;
+    }
+
+    console.log(`  Loaded ${managedSessions.size} managed sessions from: ${SESSIONS_FILE}`);
+  } catch (e) {
+    console.error('Error loading managed sessions:', e.message);
+  }
+}
+
+function saveManagedSessions() {
+  try {
+    if (!fs.existsSync(EVENTS_DIR)) {
+      fs.mkdirSync(EVENTS_DIR, { recursive: true });
+    }
+
+    const data = {
+      sessions: Array.from(managedSessions.values()),
+      claudeToManagedMap: Array.from(claudeToManagedMap.entries()),
+      sessionCounter
+    };
+    fs.writeFileSync(SESSIONS_FILE, JSON.stringify(data, null, 2));
+  } catch (e) {
+    console.error('Failed to save managed sessions:', e.message);
+  }
+}
+
+// =============================================================================
+// Custom Names
+// =============================================================================
+
+function loadCustomNames() {
+  try {
+    if (fs.existsSync(CUSTOM_NAMES_FILE)) {
+      return JSON.parse(fs.readFileSync(CUSTOM_NAMES_FILE, 'utf-8'));
+    }
+  } catch (e) { /* ignore */ }
+  return {};
+}
+
+function saveCustomNames(names) {
+  try {
+    const dir = path.dirname(CUSTOM_NAMES_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(CUSTOM_NAMES_FILE, JSON.stringify(names, null, 2));
+  } catch (e) {
+    console.error('Failed to save custom names:', e.message);
+  }
+}
+
+// =============================================================================
+// Hidden Sessions
+// =============================================================================
+
+function loadHiddenSessions() {
+  try {
+    if (fs.existsSync(HIDDEN_SESSIONS_FILE)) {
+      return JSON.parse(fs.readFileSync(HIDDEN_SESSIONS_FILE, 'utf-8'));
+    }
+  } catch (e) { /* ignore */ }
+  return [];
+}
+
+function saveHiddenSessions(hiddenIds) {
+  try {
+    const dir = path.dirname(HIDDEN_SESSIONS_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(HIDDEN_SESSIONS_FILE, JSON.stringify(hiddenIds, null, 2));
+  } catch (e) {
+    console.error('Failed to save hidden sessions:', e.message);
+  }
+}
+
+function hideSession(sessionId) {
+  const hidden = loadHiddenSessions();
+  if (!hidden.includes(sessionId)) {
+    hidden.push(sessionId);
+    saveHiddenSessions(hidden);
+  }
+  return { success: true };
+}
+
+function unhideSession(sessionId) {
+  let hidden = loadHiddenSessions();
+  hidden = hidden.filter(id => id !== sessionId);
+  saveHiddenSessions(hidden);
+  return { success: true };
+}
+
+function isSessionHidden(sessionId, claudeSessionId) {
+  const hidden = loadHiddenSessions();
+  return hidden.includes(sessionId) || (claudeSessionId && hidden.includes(claudeSessionId));
+}
+
+// =============================================================================
+// Permanent Delete
+// =============================================================================
+
+function permanentDeleteSession(sessionId) {
+  let session = managedSessions.get(sessionId);
+  let managedId = sessionId;
+
+  if (!session) {
+    for (const [id, s] of managedSessions) {
+      if (s.claudeSessionId === sessionId) {
+        session = s;
+        managedId = id;
+        break;
+      }
+    }
+  }
+
+  if (!session) {
+    return { success: false, error: 'Session not found' };
+  }
+
+  const claudeSessionId = session.claudeSessionId;
+
+  managedSessions.delete(managedId);
+  if (claudeSessionId) {
+    claudeToManagedMap.delete(claudeSessionId);
+  }
+
+  let hidden = loadHiddenSessions();
+  hidden = hidden.filter(id => id !== managedId && id !== claudeSessionId);
+  saveHiddenSessions(hidden);
+
+  const names = loadCustomNames();
+  delete names[managedId];
+  if (claudeSessionId) {
+    delete names[claudeSessionId];
+  }
+  saveCustomNames(names);
+
+  saveManagedSessions();
+  broadcastManagedSessions();
+
+  console.log(`  Permanently deleted session: ${session.name} (${managedId})`);
+  return { success: true };
+}
+
+// =============================================================================
+// Session Retrieval
+// =============================================================================
+
+function setMetadataCallback(callback) {
+  getSessionMetadataCallback = callback;
+}
+
+function getManagedSessions(includeHidden = false) {
+  const customNames = loadCustomNames();
+  const hiddenSessions = loadHiddenSessions();
+
+  return Array.from(managedSessions.values())
+    .filter(session => {
+      if (includeHidden) return true;
+      return !hiddenSessions.includes(session.id) &&
+             !hiddenSessions.includes(session.claudeSessionId);
+    })
+    .map(session => {
+      let firstPrompt = null;
+      if (session.claudeSessionId && getSessionMetadataCallback) {
+        const metadata = getSessionMetadataCallback(session.claudeSessionId);
+        firstPrompt = metadata.firstPrompt;
+      }
+      const customName = customNames[session.id] || customNames[session.claudeSessionId] || null;
+      return {
+        ...session,
+        name: customName || session.name,
+        firstPrompt,
+      };
+    });
+}
+
+function getManagedSession(id) {
+  return managedSessions.get(id);
+}
+
+function findManagedSessionByClaudeId(claudeSessionId) {
+  const managedId = claudeToManagedMap.get(claudeSessionId);
+  if (managedId) {
+    return managedSessions.get(managedId);
+  }
+  return undefined;
+}
+
+function findManagedSessionByCwd(cwd) {
+  if (!cwd) return undefined;
+  for (const session of managedSessions.values()) {
+    if (session.cwd === cwd) {
+      return session;
+    }
+  }
+  return undefined;
+}
+
+// =============================================================================
+// Session Discovery & Updates
+// =============================================================================
+
+function linkClaudeSession(claudeSessionId, managedSessionId) {
+  claudeToManagedMap.set(claudeSessionId, managedSessionId);
+  const session = managedSessions.get(managedSessionId);
+  if (session) {
+    session.claudeSessionId = claudeSessionId;
+  }
+}
+
+function discoverSession(event) {
+  const id = crypto.randomUUID();
+  const projectName = event.cwd ? path.basename(event.cwd) : 'Unknown Project';
+
+  const session = {
+    id,
+    name: projectName,
+    tmuxSession: null,
+    status: SESSION_STATUS.WORKING,
+    claudeSessionId: event.sessionId,
+    createdAt: Date.now(),
+    lastActivity: Date.now(),
+    cwd: event.cwd || null,
+    currentTool: event.tool || null,
+    discovered: true
+  };
+
+  managedSessions.set(id, session);
+  linkClaudeSession(event.sessionId, id);
+
+  console.log(`  Discovered Claude session: ${session.name} (${event.sessionId.slice(0, 8)}) in ${event.cwd || 'unknown directory'}`);
+
+  broadcastManagedSessions();
+  saveManagedSessions();
+
+  return session;
+}
+
+function updateSessionFromEvent(event) {
+  if (!event.sessionId) return;
+
+  const hiddenIds = loadHiddenSessions();
+  if (hiddenIds.includes(event.sessionId)) {
+    console.log(`  Auto-unhiding session ${event.sessionId.substring(0, 8)}... (received activity)`);
+    unhideSession(event.sessionId);
+  }
+
+  let managedSession = findManagedSessionByClaudeId(event.sessionId);
+
+  if (!managedSession) {
+    managedSession = discoverSession(event);
+  }
+
+  const prevStatus = managedSession.status;
+  managedSession.lastActivity = Date.now();
+  if (event.cwd) managedSession.cwd = event.cwd;
+
+  switch (event.type) {
+    case 'pre_tool_use':
+      managedSession.status = SESSION_STATUS.WORKING;
+      managedSession.currentTool = event.tool;
+      break;
+
+    case 'post_tool_use':
+      managedSession.currentTool = undefined;
+      break;
+
+    case 'user_prompt_submit':
+      managedSession.status = SESSION_STATUS.WORKING;
+      managedSession.currentTool = undefined;
+      break;
+
+    case 'stop':
+    case 'session_end':
+      managedSession.status = SESSION_STATUS.IDLE;
+      managedSession.currentTool = undefined;
+      break;
+  }
+
+  if (prevStatus !== managedSession.status) {
+    broadcastManagedSessions();
+    saveManagedSessions();
+  }
+}
+
+// =============================================================================
+// Session Rename
+// =============================================================================
+
+function renameSession(sessionId, newName) {
+  const names = loadCustomNames();
+  const previousName = names[sessionId];
+
+  if (newName && newName.trim()) {
+    names[sessionId] = newName.trim();
+  } else {
+    delete names[sessionId];
+  }
+  saveCustomNames(names);
+
+  let managedSession = managedSessions.get(sessionId);
+  if (!managedSession) {
+    for (const [id, session] of managedSessions) {
+      if (session.claudeSessionId === sessionId) {
+        managedSession = session;
+        break;
+      }
+    }
+  }
+  if (managedSession) {
+    managedSession.name = newName?.trim() || managedSession.name;
+    saveManagedSessions();
+    broadcastManagedSessions();
+  }
+
+  eventBus.emit(EventTypes.SESSION_RENAMED, { sessionId, newName: newName?.trim(), previousName });
+  return { success: true };
+}
+
+// =============================================================================
+// Session CRUD Operations
+// =============================================================================
+
+async function createManagedSession(options = {}) {
+  const id = crypto.randomUUID();
+  sessionCounter++;
+
+  const name = options.name || `Claude ${sessionCounter}`;
+  const tmuxSessionName = `tasks-board-${shortId()}`;
+  const cwd = options.cwd || process.cwd();
+
+  if (!fs.existsSync(cwd)) {
+    throw new Error(`Directory does not exist: ${cwd}`);
+  }
+
+  const flags = options.flags || {};
+  const claudeArgs = [];
+
+  if (flags.continue !== false) {
+    claudeArgs.push('-c');
+  }
+  if (flags.skipPermissions !== false) {
+    claudeArgs.push('--dangerously-skip-permissions');
+  }
+
+  const claudeCmd = claudeArgs.length > 0 ? `claude ${claudeArgs.join(' ')}` : 'claude';
+
+  return new Promise((resolve, reject) => {
+    execFile('tmux', [
+      'new-session', '-d', '-s', tmuxSessionName, '-c', cwd, claudeCmd
+    ], (error) => {
+      if (error) {
+        console.error(`Failed to spawn session: ${error.message}`);
+        reject(new Error(`Failed to spawn session: ${error.message}`));
+        return;
+      }
+
+      const session = {
+        id,
+        name,
+        tmuxSession: tmuxSessionName,
+        status: SESSION_STATUS.IDLE,
+        claudeSessionId: null,
+        createdAt: Date.now(),
+        lastActivity: Date.now(),
+        cwd,
+        currentTool: null
+      };
+
+      managedSessions.set(id, session);
+      console.log(`  Created managed session: ${name} (${id.slice(0, 8)}) -> tmux:${tmuxSessionName}`);
+
+      broadcastManagedSessions();
+      saveManagedSessions();
+
+      resolve(session);
+    });
+  });
+}
+
+function updateManagedSession(id, updates) {
+  const session = managedSessions.get(id);
+  if (!session) return null;
+
+  if (updates.name) {
+    session.name = updates.name;
+  }
+
+  broadcastManagedSessions();
+  saveManagedSessions();
+
+  return session;
+}
+
+async function deleteManagedSession(id) {
+  const session = managedSessions.get(id);
+  if (!session) return false;
+
+  return new Promise((resolve) => {
+    if (session.tmuxSession) {
+      execFile('tmux', ['kill-session', '-t', session.tmuxSession], (error) => {
+        if (error) {
+          console.log(`  Note: tmux session ${session.tmuxSession} may already be dead`);
+        }
+
+        managedSessions.delete(id);
+        if (session.claudeSessionId) {
+          claudeToManagedMap.delete(session.claudeSessionId);
+        }
+
+        console.log(`  Deleted managed session: ${session.name} (${id.slice(0, 8)})`);
+        broadcastManagedSessions();
+        saveManagedSessions();
+
+        resolve(true);
+      });
+    } else {
+      managedSessions.delete(id);
+      if (session.claudeSessionId) {
+        claudeToManagedMap.delete(session.claudeSessionId);
+      }
+
+      broadcastManagedSessions();
+      saveManagedSessions();
+      resolve(true);
+    }
+  });
+}
+
+async function restartManagedSession(id) {
+  const session = managedSessions.get(id);
+  if (!session) return null;
+
+  const cwd = session.cwd || process.cwd();
+
+  return new Promise((resolve, reject) => {
+    if (session.tmuxSession) {
+      execFile('tmux', ['kill-session', '-t', session.tmuxSession], () => {
+        spawnNewTmux();
+      });
+    } else {
+      spawnNewTmux();
+    }
+
+    function spawnNewTmux() {
+      const tmuxSessionName = `tasks-board-${shortId()}`;
+      const claudeCmd = 'claude -c --dangerously-skip-permissions';
+
+      execFile('tmux', [
+        'new-session', '-d', '-s', tmuxSessionName, '-c', cwd, claudeCmd
+      ], (error) => {
+        if (error) {
+          reject(new Error(`Failed to restart session: ${error.message}`));
+          return;
+        }
+
+        session.tmuxSession = tmuxSessionName;
+        session.status = SESSION_STATUS.IDLE;
+        session.currentTool = null;
+        session.lastActivity = Date.now();
+
+        console.log(`  Restarted managed session: ${session.name} -> tmux:${tmuxSessionName}`);
+        broadcastManagedSessions();
+        saveManagedSessions();
+
+        resolve(session);
+      });
+    }
+  });
+}
+
+// =============================================================================
+// Tmux Interaction
+// =============================================================================
+
+async function sendToTmux(tmuxSession, text) {
+  return new Promise((resolve, reject) => {
+    const tempFile = `/tmp/claude-tasks-prompt-${Date.now()}.txt`;
+    fs.writeFileSync(tempFile, text);
+
+    execFile('tmux', ['load-buffer', tempFile], (err) => {
+      if (err) {
+        fs.unlinkSync(tempFile);
+        return reject(new Error(`tmux load-buffer failed: ${err.message}`));
+      }
+
+      execFile('tmux', ['paste-buffer', '-t', tmuxSession], (err2) => {
+        fs.unlinkSync(tempFile);
+
+        if (err2) {
+          return reject(new Error(`tmux paste-buffer failed: ${err2.message}`));
+        }
+
+        setTimeout(() => {
+          execFile('tmux', ['send-keys', '-t', tmuxSession, 'Enter'], (err3) => {
+            if (err3) {
+              return reject(new Error(`tmux send-keys failed: ${err3.message}`));
+            }
+            resolve();
+          });
+        }, 50);
+      });
+    });
+  });
+}
+
+async function sendPromptToManagedSession(id, prompt) {
+  const session = managedSessions.get(id);
+  if (!session) {
+    return { ok: false, error: 'Session not found' };
+  }
+
+  if (!session.tmuxSession) {
+    return { ok: false, error: 'Session has no tmux session' };
+  }
+
+  if (session.status === SESSION_STATUS.OFFLINE) {
+    return { ok: false, error: 'Session is offline' };
+  }
+
+  try {
+    await sendToTmux(session.tmuxSession, prompt);
+    session.lastActivity = Date.now();
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e.message };
+  }
+}
+
+// =============================================================================
+// Health Monitoring
+// =============================================================================
+
+function checkSessionHealth() {
+  execFile('tmux', ['list-sessions', '-F', '#{session_name}'], (error, stdout) => {
+    if (error) {
+      let changed = false;
+      for (const session of managedSessions.values()) {
+        if (session.status !== SESSION_STATUS.OFFLINE) {
+          session.status = SESSION_STATUS.OFFLINE;
+          changed = true;
+        }
+      }
+      if (changed) {
+        broadcastManagedSessions();
+        saveManagedSessions();
+      }
+      return;
+    }
+
+    const activeSessions = new Set(stdout.trim().split('\n').filter(Boolean));
+    let changed = false;
+
+    for (const session of managedSessions.values()) {
+      if (!session.tmuxSession) continue;
+
+      const isAlive = activeSessions.has(session.tmuxSession);
+      let newStatus;
+
+      if (isAlive) {
+        newStatus = session.status === SESSION_STATUS.OFFLINE ? SESSION_STATUS.IDLE : session.status;
+      } else {
+        newStatus = SESSION_STATUS.OFFLINE;
+      }
+
+      if (session.status !== newStatus) {
+        session.status = newStatus;
+        if (newStatus === SESSION_STATUS.OFFLINE) {
+          session.currentTool = undefined;
+        }
+        changed = true;
+      }
+    }
+
+    if (changed) {
+      broadcastManagedSessions();
+      saveManagedSessions();
+    }
+  });
+}
+
+function checkWorkingTimeout() {
+  const now = Date.now();
+  const WORKING_TIMEOUT_MS = WORKING_TIMEOUT || 120000;
+  let changed = false;
+
+  for (const session of managedSessions.values()) {
+    if (session.status === SESSION_STATUS.WORKING) {
+      const timeSinceActivity = now - (session.lastActivity || 0);
+      if (timeSinceActivity > WORKING_TIMEOUT_MS) {
+        console.log(`  Session "${session.name}" timed out after ${Math.round(timeSinceActivity / 1000)}s of no activity`);
+        session.status = SESSION_STATUS.IDLE;
+        session.currentTool = undefined;
+        changed = true;
+      }
+    }
+  }
+
+  if (changed) {
+    broadcastManagedSessions();
+    saveManagedSessions();
+  }
+}
+
+// =============================================================================
+// Permission Detection
+// =============================================================================
+
+function detectPermissionPrompt(output) {
+  const lines = output.split('\n');
+
+  let proceedLineIdx = -1;
+  for (let i = lines.length - 1; i >= Math.max(0, lines.length - 30); i--) {
+    if (/(Do you want|Would you like) to proceed\?/i.test(lines[i])) {
+      proceedLineIdx = i;
+      break;
+    }
+  }
+
+  if (proceedLineIdx === -1) return null;
+
+  let hasFooter = false;
+  let hasSelector = false;
+  for (let i = proceedLineIdx + 1; i < Math.min(lines.length, proceedLineIdx + 15); i++) {
+    if (/Esc to cancel|ctrl-g to edit/i.test(lines[i])) {
+      hasFooter = true;
+      break;
+    }
+    if (/^\s*❯/.test(lines[i])) {
+      hasSelector = true;
+    }
+  }
+
+  if (!hasFooter && !hasSelector) return null;
+
+  let tool = 'Permission';
+  for (let i = proceedLineIdx; i >= Math.max(0, proceedLineIdx - 20); i--) {
+    const toolMatch = lines[i].match(/[●◐·]\s*(\w+)\s*\(/);
+    if (toolMatch) {
+      tool = toolMatch[1];
+      break;
+    }
+    const cmdMatch = lines[i].match(/^\s*(Bash|Read|Write|Edit|Grep|Glob|Task|WebFetch|WebSearch)\s+\w+/i);
+    if (cmdMatch) {
+      tool = cmdMatch[1];
+      break;
+    }
+  }
+
+  return { tool, context: lines.slice(Math.max(0, proceedLineIdx - 5), proceedLineIdx + 8).join('\n') };
+}
+
+function pollPermissions(session) {
+  if (!session.tmuxSession) return;
+
+  execFile('tmux', ['capture-pane', '-t', session.tmuxSession, '-p', '-S', '-50'],
+    { timeout: 2000, maxBuffer: 1024 * 1024 },
+    (error, stdout) => {
+      if (error) return;
+
+      const prompt = detectPermissionPrompt(stdout);
+      const existing = pendingPermissions.get(session.id);
+
+      if (prompt && !existing) {
+        pendingPermissions.set(session.id, {
+          tool: prompt.tool,
+          detectedAt: Date.now(),
+        });
+
+        console.log(`  Permission prompt detected for "${session.name}": ${prompt.tool}`);
+
+        if (session.status !== SESSION_STATUS.WAITING) {
+          session.status = SESSION_STATUS.WAITING;
+          session.currentTool = prompt.tool;
+          broadcastManagedSessions();
+          saveManagedSessions();
+        }
+      } else if (!prompt && existing) {
+        pendingPermissions.delete(session.id);
+        console.log(`  Permission prompt resolved for "${session.name}"`);
+
+        if (session.status === SESSION_STATUS.WAITING) {
+          session.status = SESSION_STATUS.WORKING;
+          session.currentTool = undefined;
+          broadcastManagedSessions();
+          saveManagedSessions();
+        }
+      }
+    }
+  );
+}
+
+function checkPermissionPrompts() {
+  for (const session of managedSessions.values()) {
+    if (session.tmuxSession && session.status !== SESSION_STATUS.OFFLINE) {
+      pollPermissions(session);
+    }
+  }
+}
+
+// =============================================================================
+// Broadcasting
+// =============================================================================
+
+function broadcastManagedSessions() {
+  const data = JSON.stringify({ type: 'sessions', sessions: getManagedSessions() });
+  for (const client of sseClients) {
+    try {
+      client.write(`data: ${data}\n\n`);
+    } catch (e) {
+      sseClients.delete(client);
+    }
+  }
+}
+
+// =============================================================================
+// Initialization
+// =============================================================================
+
+function startHealthChecks() {
+  setInterval(checkSessionHealth, 5000);
+  setInterval(checkWorkingTimeout, 10000);
+  setInterval(checkPermissionPrompts, 1000);
+  checkSessionHealth();
+  console.log('  Status monitoring started (health: 5s, timeout: 10s, permissions: 1s)');
+}
+
+function init() {
+  loadManagedSessions();
+  startHealthChecks();
+}
+
+module.exports = {
+  // Initialization
+  init,
+  loadManagedSessions,
+  saveManagedSessions,
+  startHealthChecks,
+
+  // Session retrieval
+  getManagedSessions,
+  getManagedSession,
+  findManagedSessionByClaudeId,
+  findManagedSessionByCwd,
+  setMetadataCallback,
+
+  // Session CRUD
+  createManagedSession,
+  updateManagedSession,
+  deleteManagedSession,
+  restartManagedSession,
+
+  // Session discovery & updates
+  discoverSession,
+  updateSessionFromEvent,
+  linkClaudeSession,
+
+  // Session rename
+  renameSession,
+
+  // Hidden sessions
+  loadHiddenSessions,
+  hideSession,
+  unhideSession,
+  isSessionHidden,
+  permanentDeleteSession,
+
+  // Tmux interaction
+  sendToTmux,
+  sendPromptToManagedSession,
+
+  // Health & permissions
+  checkSessionHealth,
+  checkWorkingTimeout,
+  checkPermissionPrompts,
+  detectPermissionPrompt,
+
+  // Broadcasting
+  broadcastManagedSessions,
+
+  // Direct access
+  managedSessions,
+  claudeToManagedMap,
+
+  // Custom names
+  loadCustomNames,
+  saveCustomNames
+};