claudehq 1.0.2 → 1.0.5

package/lib/routes/spawner.js

@@ -0,0 +1,335 @@
+/**
+ * Spawner API Routes - HTTP route handlers for session spawning
+ *
+ * Provides REST API endpoints for:
+ * - Spawning new Claude Code sessions
+ * - Managing existing sessions
+ * - Projects autocomplete and tracking
+ */
+
+/**
+ * Create spawner route handlers
+ * @param {Object} deps - Dependencies
+ * @param {Object} deps.spawner - Session spawner instance
+ * @returns {Object} Route handlers
+ */
+function createSpawnerRoutes(deps) {
+  const { spawner } = deps;
+
+  return {
+    // =========================================================================
+    // Session Spawning
+    // =========================================================================
+
+    /**
+     * POST /api/spawner/sessions - Spawn a new session
+     */
+    handleSpawnSession(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        try {
+          const {
+            name,
+            cwd,
+            model,
+            skipPermissions,
+            continue: continueConversation,
+            initialPrompt,
+            metadata
+          } = JSON.parse(body);
+
+          const result = await spawner.spawnSession({
+            name,
+            cwd,
+            model,
+            skipPermissions,
+            continue: continueConversation,
+            initialPrompt,
+            metadata
+          });
+
+          if (result.error) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, session: result.session }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    /**
+     * GET /api/spawner/sessions - List all sessions
+     */
+    handleListSessions(req, res) {
+      const sessions = spawner.listSessions();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessions }));
+    },
+
+    /**
+     * GET /api/spawner/sessions/:id - Get a specific session
+     */
+    handleGetSession(req, res, sessionId) {
+      const session = spawner.getSession(sessionId);
+      if (session) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, session }));
+      } else {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Session not found' }));
+      }
+    },
+
+    /**
+     * PATCH /api/spawner/sessions/:id - Update a session
+     */
+    handleUpdateSession(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const result = spawner.updateSession(sessionId, updates);
+
+          if (result.error) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, session: result.session }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    /**
+     * DELETE /api/spawner/sessions/:id - Kill and remove a session
+     */
+    handleKillSession(req, res, sessionId) {
+      spawner.killSession(sessionId).then((result) => {
+        if (result.error) {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: result.error }));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    /**
+     * POST /api/spawner/sessions/:id/restart - Restart a session
+     */
+    handleRestartSession(req, res, sessionId) {
+      spawner.restartSession(sessionId).then((result) => {
+        if (result.error) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: result.error }));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, session: result.session }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    /**
+     * POST /api/spawner/sessions/:id/prompt - Send a prompt to a session
+     */
+    handleSendPrompt(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        try {
+          const { prompt } = JSON.parse(body);
+          if (!prompt) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Prompt is required' }));
+            return;
+          }
+
+          const result = await spawner.sendPrompt(sessionId, prompt);
+          if (result.error) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    /**
+     * POST /api/spawner/sessions/:id/cancel - Cancel current operation
+     */
+    handleCancelSession(req, res, sessionId) {
+      spawner.cancelSession(sessionId).then((result) => {
+        if (result.error) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: result.error }));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    /**
+     * POST /api/spawner/sessions/:id/permission - Respond to permission prompt
+     */
+    handlePermissionResponse(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        try {
+          const { response } = JSON.parse(body);
+          if (!response) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Response is required' }));
+            return;
+          }
+
+          const result = await spawner.respondToPermission(sessionId, response);
+          if (result.error) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Projects
+    // =========================================================================
+
+    /**
+     * GET /api/spawner/projects - List tracked projects
+     */
+    handleListProjects(req, res, url) {
+      const limit = parseInt(url.searchParams.get('limit') || '50');
+      const sortBy = url.searchParams.get('sortBy') || 'lastUsed';
+
+      const projects = spawner.projectsManager.listProjects({ limit, sortBy });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, projects }));
+    },
+
+    /**
+     * GET /api/spawner/projects/autocomplete - Get autocomplete suggestions
+     */
+    handleAutocomplete(req, res, url) {
+      const query = url.searchParams.get('q') || '';
+      const limit = parseInt(url.searchParams.get('limit') || '15');
+
+      const suggestions = spawner.projectsManager.autocomplete(query, { limit });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, suggestions }));
+    },
+
+    /**
+     * POST /api/spawner/projects - Track a new project
+     */
+    handleTrackProject(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { path, name } = JSON.parse(body);
+          if (!path) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Path is required' }));
+            return;
+          }
+
+          const result = spawner.projectsManager.trackProject(path, name);
+          if (result.error) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          } else {
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, project: result.project }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    /**
+     * DELETE /api/spawner/projects - Remove a tracked project
+     */
+    handleRemoveProject(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { path } = JSON.parse(body);
+          if (!path) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Path is required' }));
+            return;
+          }
+
+          const result = spawner.projectsManager.removeProject(path);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, removed: result.success }));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    /**
+     * GET /api/spawner/projects/common - Get common directories
+     */
+    handleGetCommonDirectories(req, res) {
+      const directories = spawner.projectsManager.getCommonDirectories();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, directories }));
+    },
+
+    // =========================================================================
+    // Health
+    // =========================================================================
+
+    /**
+     * POST /api/spawner/refresh - Force health check
+     */
+    handleRefresh(req, res) {
+      spawner.checkHealth();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessions: spawner.listSessions() }));
+    }
+  };
+}
+
+module.exports = { createSpawnerRoutes };

package/lib/sessions/manager.js

@@ -290,20 +290,24 @@ function linkClaudeSession(claudeSessionId, managedSessionId) {
   }
 }
 
-function discoverSession(event) {
+function discoverSession(event, options = {}) {
   const id = crypto.randomUUID();
   const projectName = event.cwd ? path.basename(event.cwd) : 'Unknown Project';
 
+  // During initialization, set status to OFFLINE since we don't know if session is active
+  // During real-time discovery, set to WORKING since we're receiving live events
+  const initialStatus = options.isInitialization ? SESSION_STATUS.OFFLINE : SESSION_STATUS.WORKING;
+
   const session = {
     id,
     name: projectName,
     tmuxSession: null,
-    status: SESSION_STATUS.WORKING,
+    status: initialStatus,
     claudeSessionId: event.sessionId,
     createdAt: Date.now(),
     lastActivity: Date.now(),
     cwd: event.cwd || null,
-    currentTool: event.tool || null,
+    currentTool: options.isInitialization ? null : (event.tool || null),
     discovered: true
   };
 
@@ -318,22 +322,36 @@ function discoverSession(event) {
   return session;
 }
 
-function updateSessionFromEvent(event) {
+function updateSessionFromEvent(event, options = {}) {
   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);
+  // Skip auto-unhide during initialization (loading historical events)
+  // Only auto-unhide on new real-time events
+  if (!options.skipAutoUnhide) {
+    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);
+    managedSession = discoverSession(event, { isInitialization: options.skipAutoUnhide });
   }
 
   const prevStatus = managedSession.status;
+
+  // During initialization, only update metadata (cwd), not status
+  // Status updates from historical events would show stale "working" state
+  if (options.skipAutoUnhide) {
+    // This is initialization - only update cwd if provided
+    if (event.cwd) managedSession.cwd = event.cwd;
+    return;
+  }
+
+  // Real-time event - update everything
   managedSession.lastActivity = Date.now();
   if (event.cwd) managedSession.cwd = event.cwd;
 
@@ -466,6 +484,15 @@ function updateManagedSession(id, updates) {
 
   if (updates.name) {
     session.name = updates.name;
+
+    // Also update customNames to ensure the new name takes effect
+    // (customNames overrides session.name in getManagedSessions)
+    const customNames = loadCustomNames();
+    customNames[id] = updates.name;
+    if (session.claudeSessionId) {
+      customNames[session.claudeSessionId] = updates.name;
+    }
+    saveCustomNames(customNames);
   }
 
   broadcastManagedSessions();

package/lib/spawner/index.js

@@ -0,0 +1,51 @@
+/**
+ * Spawner Module - Session spawning and management for Claude Code
+ *
+ * This module provides the ability to spawn and manage Claude Code sessions
+ * from the dashboard without needing to open a terminal.
+ *
+ * Main exports:
+ * - createSessionSpawner: Create a session spawner instance
+ * - createProjectsManager: Create a projects manager for directory tracking
+ * - Path validation utilities
+ */
+
+const { createSessionSpawner, SESSION_STATUS, CLAUDE_MODELS, DEFAULT_CONFIG } = require('./session-spawner');
+const { createProjectsManager, MAX_TRACKED_PROJECTS, MAX_AUTOCOMPLETE_RESULTS } = require('./projects-manager');
+const {
+  validateDirectoryPath,
+  validateFilePath,
+  validateTmuxSessionName,
+  isValidTmuxSessionName,
+  containsShellMetacharacters,
+  isPathTraversalAttempt,
+  isPathWithin,
+  normalizePath,
+  sanitizeForFilename,
+  MAX_PATH_LENGTH
+} = require('./path-validator');
+
+module.exports = {
+  // Main factory functions
+  createSessionSpawner,
+  createProjectsManager,
+
+  // Path validation
+  validateDirectoryPath,
+  validateFilePath,
+  validateTmuxSessionName,
+  isValidTmuxSessionName,
+  containsShellMetacharacters,
+  isPathTraversalAttempt,
+  isPathWithin,
+  normalizePath,
+  sanitizeForFilename,
+
+  // Constants
+  SESSION_STATUS,
+  CLAUDE_MODELS,
+  DEFAULT_CONFIG,
+  MAX_PATH_LENGTH,
+  MAX_TRACKED_PROJECTS,
+  MAX_AUTOCOMPLETE_RESULTS
+};