claudehq 1.0.1 → 1.0.3

package/lib/routes/api.js

@@ -0,0 +1,1010 @@
+/**
+ * API Routes Module - HTTP route handlers
+ *
+ * All API endpoint handlers organized by domain.
+ */
+
+const { TMUX_SESSION } = require('../core/config');
+
+/**
+ * Create all API route handlers
+ * @param {Object} deps - Dependencies injection
+ * @returns {Object} Route handlers
+ */
+function createRoutes(deps) {
+  const {
+    // Core
+    sseClients,
+    claudeEvents,
+    addClaudeEvent,
+    broadcastManagedSessions,
+
+    // Sessions
+    getManagedSessions,
+    getManagedSession,
+    createManagedSession,
+    updateManagedSession,
+    deleteManagedSession,
+    sendPromptToManagedSession,
+    restartManagedSession,
+    linkClaudeSession,
+    checkSessionHealth,
+    saveManagedSessions,
+    managedSessions,
+    hideSession,
+    unhideSession,
+    permanentDeleteSession,
+    loadHiddenSessions,
+    loadCustomNames,
+    renameSession,
+
+    // Data
+    loadAllTasks,
+    updateTask,
+    createTask,
+    loadAllTodos,
+    getTodosForSession,
+    updateTodo,
+    createTodo,
+    loadAllPlans,
+    getPlansForSession,
+    getPlan,
+    updatePlan,
+    loadConversation,
+
+    // Orchestration
+    orchestrationData,
+    orchestrationExecutor,
+
+    // Utils
+    sendToTmux
+  } = deps;
+
+  return {
+    // =========================================================================
+    // SSE Events
+    // =========================================================================
+    handleSSE(req, res) {
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*'
+      });
+
+      res.write('data: {"type":"connected"}\n\n');
+
+      const recentEvents = claudeEvents.slice(-50);
+      if (recentEvents.length > 0) {
+        res.write(`data: ${JSON.stringify({ type: 'history', events: recentEvents })}\n\n`);
+      }
+
+      res.write(`data: ${JSON.stringify({ type: 'sessions', sessions: getManagedSessions() })}\n\n`);
+
+      sseClients.add(res);
+      req.on('close', () => sseClients.delete(res));
+    },
+
+    // =========================================================================
+    // Health
+    // =========================================================================
+    handleHealth(req, res) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, version: '1.0.0' }));
+    },
+
+    // =========================================================================
+    // Claude Events
+    // =========================================================================
+    handlePostClaudeEvent(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const event = JSON.parse(body);
+          addClaudeEvent(event);
+          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: 'Invalid JSON' }));
+        }
+      });
+    },
+
+    handleGetClaudeEvents(req, res, url) {
+      const limit = parseInt(url.searchParams.get('limit') || '500');
+      const sessionId = url.searchParams.get('sessionId');
+
+      let filtered = claudeEvents;
+      if (sessionId) {
+        filtered = claudeEvents.filter(e => e.sessionId === sessionId);
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        ok: true,
+        events: filtered.slice(-limit),
+        total: filtered.length
+      }));
+    },
+
+    handleGetClaudeEventStats(req, res) {
+      const toolCounts = {};
+      const toolDurations = {};
+      const sessionActivity = {};
+
+      for (const event of claudeEvents) {
+        sessionActivity[event.sessionId] = (sessionActivity[event.sessionId] || 0) + 1;
+
+        if (event.type === 'post_tool_use') {
+          toolCounts[event.tool] = (toolCounts[event.tool] || 0) + 1;
+          if (event.duration !== undefined) {
+            if (!toolDurations[event.tool]) toolDurations[event.tool] = [];
+            toolDurations[event.tool].push(event.duration);
+          }
+        }
+      }
+
+      const avgDurations = {};
+      for (const [tool, durations] of Object.entries(toolDurations)) {
+        avgDurations[tool] = Math.round(
+          durations.reduce((a, b) => a + b, 0) / durations.length
+        );
+      }
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        totalEvents: claudeEvents.length,
+        toolCounts,
+        avgDurations,
+        sessionActivity
+      }));
+    },
+
+    // =========================================================================
+    // Tasks
+    // =========================================================================
+    handleGetTasks(req, res) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(loadAllTasks()));
+    },
+
+    handleBulkUpdateTasks(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { sessionId, taskIds, updates } = JSON.parse(body);
+          if (!sessionId || !taskIds || !Array.isArray(taskIds) || !updates) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Missing sessionId, taskIds, or updates' }));
+            return;
+          }
+
+          const results = [];
+          for (const taskId of taskIds) {
+            const result = updateTask(sessionId, taskId, updates);
+            results.push({ taskId, ...result });
+          }
+
+          const failedCount = results.filter(r => r.error).length;
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            ok: failedCount === 0,
+            updated: results.filter(r => r.success).length,
+            failed: failedCount,
+            results
+          }));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleUpdateTask(req, res, sessionId, taskId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const result = updateTask(sessionId, taskId, updates);
+          res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+    },
+
+    handleCreateTask(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const taskData = JSON.parse(body);
+          const result = createTask(sessionId, taskData);
+          res.writeHead(result.error ? 400 : 201, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Todos
+    // =========================================================================
+    handleGetAllTodos(req, res) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, todosBySession: loadAllTodos() }));
+    },
+
+    handleBulkUpdateTodos(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { sessionId, todoIndexes, updates } = JSON.parse(body);
+          if (!sessionId || !todoIndexes || !Array.isArray(todoIndexes) || !updates) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Missing sessionId, todoIndexes, or updates' }));
+            return;
+          }
+
+          const results = [];
+          for (const todoIndex of todoIndexes) {
+            const result = updateTodo(sessionId, todoIndex, updates);
+            results.push({ todoIndex, ...result });
+          }
+
+          const failedCount = results.filter(r => r.error).length;
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            ok: failedCount === 0,
+            updated: results.filter(r => r.success).length,
+            failed: failedCount,
+            results
+          }));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleGetTodosForSession(req, res, sessionId) {
+      const result = getTodosForSession(sessionId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, ...result }));
+    },
+
+    handleCreateTodo(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const todoData = JSON.parse(body);
+          const result = createTodo(sessionId, todoData);
+          if (result.success) {
+            res.writeHead(201, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, todo: result.todo }));
+          } else {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleUpdateTodo(req, res, sessionId, todoIndex) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const result = updateTodo(sessionId, parseInt(todoIndex), updates);
+          if (result.success) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, todo: result.todo }));
+          } else {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Plans
+    // =========================================================================
+    handleGetAllPlans(req, res) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, plans: loadAllPlans() }));
+    },
+
+    handleGetPlansForSession(req, res, sessionId) {
+      const plans = getPlansForSession(sessionId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessionId, plans }));
+    },
+
+    handleGetPlan(req, res, slug) {
+      const result = getPlan(slug);
+      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, plan: result }));
+      }
+    },
+
+    handleUpdatePlan(req, res, slug) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { content } = JSON.parse(body);
+          const result = updatePlan(slug, content);
+          if (result.success) {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true, slug: result.slug }));
+          } else {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: result.error }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Managed Sessions
+    // =========================================================================
+    handleGetManagedSessions(req, res) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessions: getManagedSessions() }));
+    },
+
+    handleCreateManagedSession(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        try {
+          const { name, cwd, flags } = JSON.parse(body);
+          const session = await createManagedSession({ name, cwd, flags });
+          res.writeHead(201, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, session }));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleRefreshSessions(req, res) {
+      checkSessionHealth();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessions: getManagedSessions() }));
+    },
+
+    handleGetManagedSession(req, res, id) {
+      const session = getManagedSession(id);
+      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' }));
+      }
+    },
+
+    handleUpdateManagedSession(req, res, id) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const session = updateManagedSession(id, updates);
+          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' }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleHideSession(req, res, id) {
+      const session = managedSessions.get(id);
+      if (session) {
+        const idToHide = session.claudeSessionId || id;
+        hideSession(idToHide);
+        broadcastManagedSessions();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+      } else {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Session not found' }));
+      }
+    },
+
+    handleUnhideSession(req, res, id) {
+      unhideSession(id);
+      broadcastManagedSessions();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true }));
+    },
+
+    handleGetHiddenSessions(req, res) {
+      const hiddenIds = loadHiddenSessions();
+      const customNames = loadCustomNames();
+      const sessions = hiddenIds.map(id => {
+        let name = customNames[id] || id.substring(0, 8);
+        for (const [managedId, session] of managedSessions) {
+          if (session.claudeSessionId === id || managedId === id) {
+            name = session.name || name;
+            break;
+          }
+        }
+        return { id, name };
+      });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, sessions }));
+    },
+
+    handleDeleteSession(req, res, id) {
+      const session = managedSessions.get(id);
+      if (session) {
+        const idToHide = session.claudeSessionId || id;
+        hideSession(idToHide);
+        broadcastManagedSessions();
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+      } else {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Session not found' }));
+      }
+    },
+
+    handlePermanentDeleteSession(req, res, id) {
+      const result = permanentDeleteSession(id);
+      if (result.success) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true }));
+      } else {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: result.error }));
+      }
+    },
+
+    handleSendPromptToSession(req, res, id) {
+      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 sendPromptToManagedSession(id, prompt);
+          res.writeHead(result.ok ? 200 : 404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleRestartSession(req, res, id) {
+      restartManagedSession(id).then((session) => {
+        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' }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    handleLinkSession(req, res, id) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { claudeSessionId } = JSON.parse(body);
+          if (!claudeSessionId) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'claudeSessionId is required' }));
+            return;
+          }
+          const session = getManagedSession(id);
+          if (!session) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Session not found' }));
+            return;
+          }
+          linkClaudeSession(claudeSessionId, id);
+          broadcastManagedSessions();
+          saveManagedSessions();
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, session: getManagedSession(id) }));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Conversation
+    // =========================================================================
+    handleGetConversation(req, res, sessionId) {
+      const conversation = loadConversation(sessionId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(conversation));
+    },
+
+    // =========================================================================
+    // Prompt
+    // =========================================================================
+    handleSendPrompt(req, res) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', async () => {
+        try {
+          const { prompt, tmuxSession } = JSON.parse(body);
+          if (!prompt) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Prompt is required' }));
+            return;
+          }
+          const session = tmuxSession || TMUX_SESSION;
+          await sendToTmux(session, prompt);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: true, session }));
+        } catch (e) {
+          res.writeHead(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleRenameSession(req, res, sessionId) {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { name } = JSON.parse(body);
+          const result = renameSession(sessionId, name);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(result));
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: e.message }));
+        }
+      });
+    },
+
+    // =========================================================================
+    // Orchestration
+    // =========================================================================
+    handleGetOrchestrations(req, res) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const orchestrations = orchestrationData.listOrchestrations();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, orchestrations }));
+    },
+
+    handleCreateOrchestration(req, res) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const config = JSON.parse(body);
+          const result = orchestrationData.createOrchestration(config);
+          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, orchestration: result.orchestration }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleGetOrchestration(req, res, orchestrationId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const orchestration = orchestrationData.getOrchestration(orchestrationId);
+      if (!orchestration) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not found' }));
+        return;
+      }
+      const stats = orchestrationData.getOrchestrationStats(orchestrationId);
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, orchestration, stats }));
+    },
+
+    handleUpdateOrchestration(req, res, orchestrationId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const result = orchestrationData.updateOrchestration(orchestrationId, updates);
+          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, orchestration: result.orchestration }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleDeleteOrchestration(req, res, orchestrationId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const result = orchestrationData.deleteOrchestration(orchestrationId);
+      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 }));
+      }
+    },
+
+    handleStartOrchestration(req, res, orchestrationId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      orchestrationExecutor.startOrchestration(orchestrationId).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, ...result }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    handleStopOrchestration(req, res, orchestrationId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      orchestrationExecutor.stopOrchestration(orchestrationId).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, ...result }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    // Agent routes
+    handleAddAgent(req, res, orchestrationId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const agentConfig = JSON.parse(body);
+          const result = orchestrationData.addAgent(orchestrationId, agentConfig);
+          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, agent: result.agent }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleUpdateAgent(req, res, orchestrationId, agentId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const updates = JSON.parse(body);
+          const result = orchestrationData.updateAgent(orchestrationId, agentId, updates);
+          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, agent: result.agent }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleRemoveAgent(req, res, orchestrationId, agentId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const result = orchestrationData.removeAgent(orchestrationId, agentId);
+      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 }));
+      }
+    },
+
+    handleSpawnAgent(req, res, orchestrationId, agentId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      orchestrationExecutor.spawnAgent(orchestrationId, agentId).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, ...result }));
+        }
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    handleKillAgent(req, res, orchestrationId, agentId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      orchestrationExecutor.killAgent(orchestrationId, agentId).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 }));
+      });
+    },
+
+    handleSendPromptToAgent(req, res, orchestrationId, agentId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      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 orchestrationExecutor.sendPromptToAgent(orchestrationId, agentId, 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(500, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    },
+
+    handleGetAgentStatus(req, res, orchestrationId, agentId) {
+      if (!orchestrationExecutor) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration executor not available' }));
+        return;
+      }
+      orchestrationExecutor.getAgentTmuxStatus(agentId).then((status) => {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, ...status }));
+      }).catch((e) => {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: e.message }));
+      });
+    },
+
+    handleAddAgentDependency(req, res, orchestrationId, agentId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const { dependsOnAgentId } = JSON.parse(body);
+          if (!dependsOnAgentId) {
+            res.writeHead(400, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'dependsOnAgentId is required' }));
+            return;
+          }
+          const result = orchestrationData.addAgentDependency(orchestrationId, agentId, dependsOnAgentId);
+          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 }));
+        }
+      });
+    },
+
+    handleRemoveAgentDependency(req, res, orchestrationId, agentId, dependsOnAgentId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const result = orchestrationData.removeAgentDependency(orchestrationId, agentId, dependsOnAgentId);
+      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 }));
+      }
+    },
+
+    // Template routes
+    handleGetTemplates(req, res) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const templates = orchestrationData.getTemplates();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, templates }));
+    },
+
+    handleGetTemplate(req, res, templateId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      const template = orchestrationData.getTemplate(templateId);
+      if (!template) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Template not found' }));
+        return;
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, template }));
+    },
+
+    handleCreateFromTemplate(req, res, templateId) {
+      if (!orchestrationData) {
+        res.writeHead(501, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'Orchestration not available' }));
+        return;
+      }
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          const options = body ? JSON.parse(body) : {};
+          const result = orchestrationData.createFromTemplate(templateId, options);
+          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, orchestration: result.orchestration }));
+          }
+        } catch (e) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, error: e.message }));
+        }
+      });
+    }
+  };
+}
+
+module.exports = { createRoutes };