claudehq 1.0.2 → 1.0.5

package/lib/spawner/session-spawner.js

@@ -0,0 +1,1010 @@
+/**
+ * Session Spawner - Spawn and manage Claude Code sessions
+ *
+ * Main module for creating Claude Code sessions in tmux.
+ * Provides safe command building, model selection, and lifecycle management.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+const os = require('os');
+
+const { validateDirectoryPath, validateTmuxSessionName, normalizePath } = require('./path-validator');
+const { createProjectsManager } = require('./projects-manager');
+
+// Session status constants
+const SESSION_STATUS = {
+  IDLE: 'idle',
+  WORKING: 'working',
+  WAITING: 'waiting',
+  OFFLINE: 'offline'
+};
+
+// Available Claude models
+const CLAUDE_MODELS = {
+  SONNET: 'sonnet',
+  OPUS: 'opus',
+  HAIKU: 'haiku'
+};
+
+// Default configuration
+const DEFAULT_CONFIG = {
+  dataDir: path.join(os.homedir(), '.claude', 'tasks-board'),
+  sessionPrefix: 'tasks-board',
+  healthCheckInterval: 5000,
+  workingTimeout: 5 * 60 * 1000,
+  permissionPollInterval: 1000,
+  defaultModel: null, // Use Claude's default
+  defaultSkipPermissions: true,
+  defaultContinue: true
+};
+
+/**
+ * Create a session spawner instance
+ * @param {Object} options - Configuration options
+ * @returns {Object} Session spawner instance
+ */
+function createSessionSpawner(options = {}) {
+  const config = { ...DEFAULT_CONFIG, ...options };
+  const dataDir = config.dataDir;
+  const sessionsFile = path.join(dataDir, 'spawned-sessions.json');
+
+  // In-memory session storage
+  const sessions = new Map();
+  const claudeToSessionMap = new Map(); // Claude session ID -> spawned session ID
+  let sessionCounter = 0;
+
+  // Permission tracking
+  const pendingPermissions = new Map();
+
+  // Projects manager
+  const projectsManager = createProjectsManager({ dataDir });
+
+  // Health check interval handles
+  let healthCheckInterval = null;
+  let workingTimeoutInterval = null;
+  let permissionPollInterval = null;
+
+  // Callbacks for external notification
+  let onSessionUpdate = null;
+  let onPermissionDetected = null;
+
+  /**
+   * Generate a short random ID
+   * @returns {string} Short ID
+   */
+  function shortId() {
+    return crypto.randomBytes(4).toString('hex');
+  }
+
+  /**
+   * Generate a unique session ID
+   * @returns {string} UUID
+   */
+  function generateSessionId() {
+    return crypto.randomUUID();
+  }
+
+  /**
+   * Generate a tmux session name
+   * @param {string} suffix - Optional suffix
+   * @returns {string} Tmux session name
+   */
+  function generateTmuxSessionName(suffix = null) {
+    const name = suffix
+      ? `${config.sessionPrefix}-${suffix}`
+      : `${config.sessionPrefix}-${shortId()}`;
+    return name;
+  }
+
+  /**
+   * Ensure data directory exists
+   */
+  function ensureDataDir() {
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Load sessions from disk
+   */
+  function loadSessions() {
+    try {
+      if (fs.existsSync(sessionsFile)) {
+        const content = fs.readFileSync(sessionsFile, 'utf-8');
+        const data = JSON.parse(content);
+
+        sessions.clear();
+        claudeToSessionMap.clear();
+
+        if (Array.isArray(data.sessions)) {
+          for (const session of data.sessions) {
+            // Mark all as offline on load - health check will update
+            session.status = SESSION_STATUS.OFFLINE;
+            session.currentTool = null;
+            sessions.set(session.id, session);
+
+            if (session.claudeSessionId) {
+              claudeToSessionMap.set(session.claudeSessionId, session.id);
+            }
+          }
+        }
+
+        if (typeof data.sessionCounter === 'number') {
+          sessionCounter = data.sessionCounter;
+        }
+
+        console.log(`  Loaded ${sessions.size} spawned sessions`);
+      }
+    } catch (e) {
+      console.error('Error loading spawned sessions:', e.message);
+    }
+  }
+
+  /**
+   * Save sessions to disk
+   */
+  function saveSessions() {
+    try {
+      ensureDataDir();
+
+      const data = {
+        version: 1,
+        updatedAt: new Date().toISOString(),
+        sessions: Array.from(sessions.values()),
+        claudeToSessionMap: Array.from(claudeToSessionMap.entries()),
+        sessionCounter
+      };
+
+      fs.writeFileSync(sessionsFile, JSON.stringify(data, null, 2));
+    } catch (e) {
+      console.error('Error saving spawned sessions:', e.message);
+    }
+  }
+
+  /**
+   * Build the Claude command with flags
+   * @param {Object} opts - Command options
+   * @returns {string} Claude command string
+   */
+  function buildClaudeCommand(opts = {}) {
+    const args = ['claude'];
+
+    // Continue conversation
+    if (opts.continue !== false && config.defaultContinue) {
+      args.push('-c');
+    }
+
+    // Skip permissions
+    if (opts.skipPermissions !== false && config.defaultSkipPermissions) {
+      args.push('--dangerously-skip-permissions');
+    }
+
+    // Model selection
+    const model = opts.model || config.defaultModel;
+    if (model && model !== 'sonnet') {
+      args.push('--model', model);
+    }
+
+    // Initial prompt (if provided, use -p for print mode with prompt)
+    // Note: We typically send prompts after spawning instead
+    if (opts.initialPrompt) {
+      // Don't add -p here as we want interactive mode
+      // We'll send the prompt via tmux after spawning
+    }
+
+    return args.join(' ');
+  }
+
+  /**
+   * Spawn a new Claude Code session
+   * @param {Object} opts - Spawn options
+   * @param {string} opts.name - Session display name
+   * @param {string} opts.cwd - Working directory
+   * @param {string} opts.model - Claude model (sonnet, opus, haiku)
+   * @param {boolean} opts.skipPermissions - Skip permission prompts
+   * @param {boolean} opts.continue - Continue previous conversation
+   * @param {string} opts.initialPrompt - Initial prompt to send
+   * @returns {Promise<Object>} Result with session or error
+   */
+  async function spawnSession(opts = {}) {
+    // Validate working directory
+    const cwd = opts.cwd || process.cwd();
+    const cwdValidation = validateDirectoryPath(cwd);
+    if (!cwdValidation.valid) {
+      return { error: cwdValidation.error };
+    }
+
+    const workingDirectory = cwdValidation.path;
+
+    // Generate session info
+    const id = generateSessionId();
+    sessionCounter++;
+    const name = opts.name || `Claude ${sessionCounter}`;
+    const tmuxSessionName = generateTmuxSessionName();
+
+    // Validate tmux session name
+    try {
+      validateTmuxSessionName(tmuxSessionName);
+    } catch (e) {
+      return { error: e.message };
+    }
+
+    // Build command
+    const claudeCmd = buildClaudeCommand({
+      model: opts.model,
+      skipPermissions: opts.skipPermissions,
+      continue: opts.continue,
+      initialPrompt: opts.initialPrompt
+    });
+
+    // Spawn tmux session
+    return new Promise((resolve) => {
+      execFile('tmux', [
+        'new-session',
+        '-d',
+        '-s', tmuxSessionName,
+        '-c', workingDirectory,
+        claudeCmd
+      ], (error) => {
+        if (error) {
+          console.error(`Failed to spawn session: ${error.message}`);
+          resolve({ error: `Failed to spawn session: ${error.message}` });
+          return;
+        }
+
+        // Create session record
+        const session = {
+          id,
+          name,
+          tmuxSession: tmuxSessionName,
+          status: SESSION_STATUS.IDLE,
+          claudeSessionId: null,
+          cwd: workingDirectory,
+          model: opts.model || null,
+          createdAt: Date.now(),
+          lastActivity: Date.now(),
+          currentTool: null,
+          metadata: opts.metadata || {}
+        };
+
+        sessions.set(id, session);
+        saveSessions();
+
+        // Track project
+        projectsManager.trackProject(workingDirectory, path.basename(workingDirectory));
+
+        console.log(`  Spawned session "${name}" (${id.slice(0, 8)}) -> tmux:${tmuxSessionName} in ${workingDirectory}`);
+
+        // Notify listeners
+        notifySessionUpdate();
+
+        // Send initial prompt if provided
+        if (opts.initialPrompt) {
+          setTimeout(() => {
+            sendPrompt(id, opts.initialPrompt);
+          }, 1000); // Wait for Claude to initialize
+        }
+
+        resolve({ success: true, session });
+      });
+    });
+  }
+
+  /**
+   * Send text to a tmux session safely
+   * @param {string} tmuxSession - Tmux session name
+   * @param {string} text - Text to send
+   * @returns {Promise<Object>} Result
+   */
+  async function sendToTmux(tmuxSession, text) {
+    // Validate session name
+    try {
+      validateTmuxSessionName(tmuxSession);
+    } catch (e) {
+      return { error: e.message };
+    }
+
+    return new Promise((resolve) => {
+      // Use a temp file to safely inject text (prevents shell injection)
+      const tempFile = `/tmp/claude-tasks-prompt-${Date.now()}-${shortId()}.txt`;
+
+      try {
+        fs.writeFileSync(tempFile, text);
+      } catch (e) {
+        resolve({ error: `Failed to write temp file: ${e.message}` });
+        return;
+      }
+
+      // Load into tmux buffer
+      execFile('tmux', ['load-buffer', tempFile], (err) => {
+        if (err) {
+          try { fs.unlinkSync(tempFile); } catch (e) { /* ignore */ }
+          resolve({ error: `tmux load-buffer failed: ${err.message}` });
+          return;
+        }
+
+        // Paste into session
+        execFile('tmux', ['paste-buffer', '-t', tmuxSession], (err2) => {
+          try { fs.unlinkSync(tempFile); } catch (e) { /* ignore */ }
+
+          if (err2) {
+            resolve({ error: `tmux paste-buffer failed: ${err2.message}` });
+            return;
+          }
+
+          // Send Enter key
+          setTimeout(() => {
+            execFile('tmux', ['send-keys', '-t', tmuxSession, 'Enter'], (err3) => {
+              if (err3) {
+                resolve({ error: `tmux send-keys failed: ${err3.message}` });
+                return;
+              }
+              resolve({ success: true });
+            });
+          }, 50);
+        });
+      });
+    });
+  }
+
+  /**
+   * Send a prompt to a session
+   * @param {string} sessionId - Session ID
+   * @param {string} prompt - Prompt text
+   * @returns {Promise<Object>} Result
+   */
+  async function sendPrompt(sessionId, prompt) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    if (!session.tmuxSession) {
+      return { error: 'Session has no tmux session' };
+    }
+
+    if (session.status === SESSION_STATUS.OFFLINE) {
+      return { error: 'Session is offline' };
+    }
+
+    const result = await sendToTmux(session.tmuxSession, prompt);
+    if (result.success) {
+      session.lastActivity = Date.now();
+      saveSessions();
+    }
+
+    return result;
+  }
+
+  /**
+   * Send Ctrl+C to cancel current operation
+   * @param {string} sessionId - Session ID
+   * @returns {Promise<Object>} Result
+   */
+  async function cancelSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    if (!session.tmuxSession) {
+      return { error: 'Session has no tmux session' };
+    }
+
+    return new Promise((resolve) => {
+      execFile('tmux', ['send-keys', '-t', session.tmuxSession, 'C-c'], (err) => {
+        if (err) {
+          resolve({ error: err.message });
+          return;
+        }
+        resolve({ success: true });
+      });
+    });
+  }
+
+  /**
+   * Kill a session
+   * @param {string} sessionId - Session ID
+   * @returns {Promise<Object>} Result
+   */
+  async function killSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    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`);
+          }
+
+          removeSession(sessionId);
+          resolve({ success: true });
+        });
+      } else {
+        removeSession(sessionId);
+        resolve({ success: true });
+      }
+    });
+  }
+
+  /**
+   * Remove a session from tracking
+   * @param {string} sessionId - Session ID
+   */
+  function removeSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (session) {
+      if (session.claudeSessionId) {
+        claudeToSessionMap.delete(session.claudeSessionId);
+      }
+      sessions.delete(sessionId);
+      pendingPermissions.delete(sessionId);
+      saveSessions();
+      notifySessionUpdate();
+      console.log(`  Removed session ${sessionId.slice(0, 8)}`);
+    }
+  }
+
+  /**
+   * Restart a session
+   * @param {string} sessionId - Session ID
+   * @returns {Promise<Object>} Result with session or error
+   */
+  async function restartSession(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    const cwd = session.cwd || process.cwd();
+    const name = session.name;
+    const model = session.model;
+
+    // Kill old tmux session
+    if (session.tmuxSession) {
+      await new Promise((resolve) => {
+        execFile('tmux', ['kill-session', '-t', session.tmuxSession], () => resolve());
+      });
+    }
+
+    // Create new tmux session
+    const tmuxSessionName = generateTmuxSessionName();
+    const claudeCmd = buildClaudeCommand({ model });
+
+    return new Promise((resolve) => {
+      execFile('tmux', [
+        'new-session',
+        '-d',
+        '-s', tmuxSessionName,
+        '-c', cwd,
+        claudeCmd
+      ], (error) => {
+        if (error) {
+          resolve({ error: `Failed to restart session: ${error.message}` });
+          return;
+        }
+
+        // Update session
+        session.tmuxSession = tmuxSessionName;
+        session.status = SESSION_STATUS.IDLE;
+        session.currentTool = null;
+        session.lastActivity = Date.now();
+        session.claudeSessionId = null; // Will be re-linked on activity
+
+        // Clear old mapping
+        for (const [claudeId, mappedId] of claudeToSessionMap.entries()) {
+          if (mappedId === sessionId) {
+            claudeToSessionMap.delete(claudeId);
+          }
+        }
+
+        saveSessions();
+        notifySessionUpdate();
+
+        console.log(`  Restarted session "${name}" -> tmux:${tmuxSessionName}`);
+        resolve({ success: true, session });
+      });
+    });
+  }
+
+  /**
+   * Update a session
+   * @param {string} sessionId - Session ID
+   * @param {Object} updates - Updates to apply
+   * @returns {Object} Result
+   */
+  function updateSession(sessionId, updates) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    if (updates.name !== undefined) {
+      session.name = updates.name;
+    }
+    if (updates.metadata !== undefined) {
+      session.metadata = { ...session.metadata, ...updates.metadata };
+    }
+
+    saveSessions();
+    notifySessionUpdate();
+
+    return { success: true, session };
+  }
+
+  /**
+   * Get a session by ID
+   * @param {string} sessionId - Session ID
+   * @returns {Object|null} Session or null
+   */
+  function getSession(sessionId) {
+    return sessions.get(sessionId) || null;
+  }
+
+  /**
+   * Get all sessions
+   * @returns {Array} Array of sessions
+   */
+  function listSessions() {
+    return Array.from(sessions.values());
+  }
+
+  /**
+   * Find session by Claude session ID
+   * @param {string} claudeSessionId - Claude session ID
+   * @returns {Object|null} Session or null
+   */
+  function findByClaudeSessionId(claudeSessionId) {
+    const sessionId = claudeToSessionMap.get(claudeSessionId);
+    if (sessionId) {
+      return sessions.get(sessionId);
+    }
+    return null;
+  }
+
+  /**
+   * Link a Claude session ID to a spawned session
+   * @param {string} claudeSessionId - Claude session ID
+   * @param {string} sessionId - Spawned session ID
+   */
+  function linkClaudeSession(claudeSessionId, sessionId) {
+    claudeToSessionMap.set(claudeSessionId, sessionId);
+    const session = sessions.get(sessionId);
+    if (session) {
+      session.claudeSessionId = claudeSessionId;
+      saveSessions();
+    }
+  }
+
+  /**
+   * Update session from a Claude hook event
+   * @param {Object} event - Hook event
+   */
+  function updateFromEvent(event) {
+    if (!event.sessionId) return;
+
+    let session = findByClaudeSessionId(event.sessionId);
+
+    if (!session) {
+      // Try to match by cwd
+      if (event.cwd) {
+        const normalizedCwd = normalizePath(event.cwd);
+        for (const s of sessions.values()) {
+          if (s.cwd === normalizedCwd && !s.claudeSessionId) {
+            session = s;
+            linkClaudeSession(event.sessionId, s.id);
+            break;
+          }
+        }
+      }
+    }
+
+    if (!session) return;
+
+    const prevStatus = session.status;
+    session.lastActivity = Date.now();
+    if (event.cwd) {
+      session.cwd = normalizePath(event.cwd);
+    }
+
+    switch (event.type) {
+      case 'pre_tool_use':
+        session.status = SESSION_STATUS.WORKING;
+        session.currentTool = event.tool;
+        break;
+
+      case 'post_tool_use':
+        session.currentTool = null;
+        break;
+
+      case 'user_prompt_submit':
+        session.status = SESSION_STATUS.WORKING;
+        session.currentTool = null;
+        break;
+
+      case 'stop':
+      case 'session_end':
+        session.status = SESSION_STATUS.IDLE;
+        session.currentTool = null;
+        break;
+    }
+
+    if (prevStatus !== session.status) {
+      saveSessions();
+      notifySessionUpdate();
+    }
+  }
+
+  /**
+   * Check health of all sessions
+   */
+  function checkHealth() {
+    execFile('tmux', ['list-sessions', '-F', '#{session_name}'], (error, stdout) => {
+      if (error) {
+        // No tmux server or sessions
+        let changed = false;
+        for (const session of sessions.values()) {
+          if (session.status !== SESSION_STATUS.OFFLINE) {
+            session.status = SESSION_STATUS.OFFLINE;
+            session.currentTool = null;
+            changed = true;
+          }
+        }
+        if (changed) {
+          saveSessions();
+          notifySessionUpdate();
+        }
+        return;
+      }
+
+      const activeSessions = new Set(stdout.trim().split('\n').filter(Boolean));
+      let changed = false;
+
+      for (const session of sessions.values()) {
+        if (!session.tmuxSession) continue;
+
+        const isAlive = activeSessions.has(session.tmuxSession);
+        const newStatus = isAlive
+          ? (session.status === SESSION_STATUS.OFFLINE ? SESSION_STATUS.IDLE : session.status)
+          : SESSION_STATUS.OFFLINE;
+
+        if (session.status !== newStatus) {
+          session.status = newStatus;
+          if (newStatus === SESSION_STATUS.OFFLINE) {
+            session.currentTool = null;
+          }
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        saveSessions();
+        notifySessionUpdate();
+      }
+    });
+  }
+
+  /**
+   * Check for working timeout
+   */
+  function checkWorkingTimeout() {
+    const now = Date.now();
+    let changed = false;
+
+    for (const session of sessions.values()) {
+      if (session.status === SESSION_STATUS.WORKING) {
+        const timeSinceActivity = now - (session.lastActivity || 0);
+        if (timeSinceActivity > config.workingTimeout) {
+          console.log(`  Session "${session.name}" timed out after ${Math.round(timeSinceActivity / 1000)}s`);
+          session.status = SESSION_STATUS.IDLE;
+          session.currentTool = null;
+          changed = true;
+        }
+      }
+    }
+
+    if (changed) {
+      saveSessions();
+      notifySessionUpdate();
+    }
+  }
+
+  /**
+   * Detect permission prompt in tmux output
+   * @param {string} output - Tmux pane output
+   * @returns {Object|null} Permission info or null
+   */
+  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;
+
+    // Look for confirmation footer or selector
+    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;
+
+    // Find tool name
+    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') };
+  }
+
+  /**
+   * Poll a session for permission prompts
+   * @param {Object} session - Session to poll
+   */
+  function pollSessionPermissions(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;
+            saveSessions();
+            notifySessionUpdate();
+          }
+
+          if (onPermissionDetected) {
+            onPermissionDetected(session.id, prompt);
+          }
+        } 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 = null;
+            saveSessions();
+            notifySessionUpdate();
+          }
+        }
+      }
+    );
+  }
+
+  /**
+   * Check all sessions for permission prompts
+   */
+  function checkPermissions() {
+    for (const session of sessions.values()) {
+      if (session.tmuxSession && session.status !== SESSION_STATUS.OFFLINE) {
+        pollSessionPermissions(session);
+      }
+    }
+  }
+
+  /**
+   * Respond to a permission prompt
+   * @param {string} sessionId - Session ID
+   * @param {string} response - Response ('yes', 'no', '1', '2', etc.)
+   * @returns {Promise<Object>} Result
+   */
+  async function respondToPermission(sessionId, response) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+      return { error: 'Session not found' };
+    }
+
+    if (!session.tmuxSession) {
+      return { error: 'Session has no tmux session' };
+    }
+
+    // Map common responses to numbers
+    let key = response;
+    if (response.toLowerCase() === 'yes' || response === 'y') {
+      key = '1';
+    } else if (response.toLowerCase() === 'no' || response === 'n') {
+      key = '2';
+    }
+
+    return new Promise((resolve) => {
+      execFile('tmux', ['send-keys', '-t', session.tmuxSession, key], (err) => {
+        if (err) {
+          resolve({ error: err.message });
+          return;
+        }
+
+        // Clear pending permission
+        pendingPermissions.delete(sessionId);
+        session.status = SESSION_STATUS.WORKING;
+        session.currentTool = null;
+        saveSessions();
+        notifySessionUpdate();
+
+        resolve({ success: true });
+      });
+    });
+  }
+
+  /**
+   * Notify listeners of session update
+   */
+  function notifySessionUpdate() {
+    if (onSessionUpdate) {
+      onSessionUpdate(listSessions());
+    }
+  }
+
+  /**
+   * Set callback for session updates
+   * @param {Function} callback - Callback function
+   */
+  function setOnSessionUpdate(callback) {
+    onSessionUpdate = callback;
+  }
+
+  /**
+   * Set callback for permission detection
+   * @param {Function} callback - Callback function
+   */
+  function setOnPermissionDetected(callback) {
+    onPermissionDetected = callback;
+  }
+
+  /**
+   * Start health monitoring
+   */
+  function startHealthChecks() {
+    if (healthCheckInterval) {
+      clearInterval(healthCheckInterval);
+    }
+    if (workingTimeoutInterval) {
+      clearInterval(workingTimeoutInterval);
+    }
+    if (permissionPollInterval) {
+      clearInterval(permissionPollInterval);
+    }
+
+    healthCheckInterval = setInterval(checkHealth, config.healthCheckInterval);
+    workingTimeoutInterval = setInterval(checkWorkingTimeout, 10000);
+    permissionPollInterval = setInterval(checkPermissions, config.permissionPollInterval);
+
+    // Run initial health check
+    checkHealth();
+
+    console.log('  Session spawner health monitoring started');
+  }
+
+  /**
+   * Stop health monitoring
+   */
+  function stopHealthChecks() {
+    if (healthCheckInterval) {
+      clearInterval(healthCheckInterval);
+      healthCheckInterval = null;
+    }
+    if (workingTimeoutInterval) {
+      clearInterval(workingTimeoutInterval);
+      workingTimeoutInterval = null;
+    }
+    if (permissionPollInterval) {
+      clearInterval(permissionPollInterval);
+      permissionPollInterval = null;
+    }
+  }
+
+  /**
+   * Initialize the spawner
+   */
+  function init() {
+    loadSessions();
+    startHealthChecks();
+  }
+
+  /**
+   * Shutdown the spawner
+   */
+  function shutdown() {
+    stopHealthChecks();
+    saveSessions();
+  }
+
+  return {
+    // Session lifecycle
+    spawnSession,
+    killSession,
+    restartSession,
+    removeSession,
+
+    // Session interaction
+    sendPrompt,
+    cancelSession,
+    respondToPermission,
+
+    // Session management
+    getSession,
+    listSessions,
+    updateSession,
+    findByClaudeSessionId,
+    linkClaudeSession,
+    updateFromEvent,
+
+    // Health monitoring
+    checkHealth,
+    checkWorkingTimeout,
+    checkPermissions,
+    startHealthChecks,
+    stopHealthChecks,
+
+    // Projects
+    projectsManager,
+
+    // Callbacks
+    setOnSessionUpdate,
+    setOnPermissionDetected,
+
+    // Lifecycle
+    init,
+    shutdown,
+    loadSessions,
+    saveSessions,
+
+    // Direct access (for testing)
+    _sessions: sessions,
+    _claudeToSessionMap: claudeToSessionMap,
+
+    // Constants
+    SESSION_STATUS,
+    CLAUDE_MODELS
+  };
+}
+
+module.exports = {
+  createSessionSpawner,
+  SESSION_STATUS,
+  CLAUDE_MODELS,
+  DEFAULT_CONFIG
+};