@ebowwa/terminal 0.2.0

package/src/api.ts

@@ -0,0 +1,752 @@
+/**
+ * API routes for Multi-Node Tmux Session Manager
+ * Provides REST API for managing tmux sessions across multiple VPS nodes
+ */
+
+import { Hono } from "hono";
+import { z } from "zod";
+import { addActivity } from "../lib/activities";
+import {
+  getTmuxManager,
+  type Node,
+  type BatchOperationResult,
+  type DetailedTmuxSession,
+} from "./tmux-manager.js";
+import {
+  TmuxManagerAddNodeSchema,
+  TmuxManagerCreateSessionSchema,
+  TmuxManagerAttachSessionSchema,
+  TmuxManagerKillSessionSchema,
+  TmuxManagerSendCommandSchema,
+  TmuxManagerBatchSendCommandSchema,
+  TmuxManagerSplitPaneSchema,
+  TmuxManagerCapturePaneSchema,
+  TmuxManagerGetHistorySchema,
+  TmuxManagerListWindowsSchema,
+  TmuxManagerListPanesSchema,
+  TmuxManagerSwitchWindowSchema,
+  TmuxManagerSwitchPaneSchema,
+  TmuxManagerRenameWindowSchema,
+  TmuxManagerKillPaneSchema,
+  TmuxManagerCleanupOldSessionsSchema,
+  TmuxManagerDetailedSessionSchema,
+  TmuxManagerListSessionsQuerySchema,
+} from "@ebowwa/codespaces-types/runtime/api";
+
+const tmuxApi = new Hono();
+
+/**
+ * Helper function to validate request body against Zod schema
+ */
+function validateRequest<T>(
+  schema: z.ZodSchema<T>,
+  data: unknown
+): { success: true; data: T } | { success: false; error: string } {
+  try {
+    const result = schema.safeParse(data);
+    if (result.success) {
+      return { success: true, data: result.data };
+    } else {
+      return {
+        success: false,
+        error: result.error.issues
+          .map((e) => `${e.path.join(".")}: ${e.message}`)
+          .join(", "),
+      };
+    }
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+}
+
+// ============================================
+// Node Management
+// ============================================
+
+/**
+ * POST /api/tmux/manager/nodes - Add a node to the manager
+ */
+tmuxApi.post("/manager/nodes", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerAddNodeSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    manager.addNode(validation.data);
+    return c.json({ success: true, node: validation.data });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * GET /api/tmux/manager/nodes - List all nodes
+ */
+tmuxApi.get("/manager/nodes", async (c) => {
+  try {
+    const manager = getTmuxManager();
+    const nodes = manager.getAllNodes();
+    return c.json({ success: true, nodes });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * GET /api/tmux/manager/nodes/:id - Get a specific node
+ */
+tmuxApi.get("/manager/nodes/:id", async (c) => {
+  const id = c.req.param("id");
+  if (!id) {
+    return c.json({ success: false, error: "Node ID is required" }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(id);
+    if (!node) {
+      return c.json({ success: false, error: "Node not found" }, 404);
+    }
+    return c.json({ success: true, node });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * DELETE /api/tmux/manager/nodes/:id - Remove a node
+ */
+tmuxApi.delete("/manager/nodes/:id", async (c) => {
+  const id = c.req.param("id");
+  if (!id) {
+    return c.json({ success: false, error: "Node ID is required" }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(id);
+    if (!node) {
+      return c.json({ success: false, error: "Node not found" }, 404);
+    }
+    manager.removeNode(id);
+    return c.json({ success: true });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+// ============================================
+// Session Management
+// ============================================
+
+/**
+ * POST /api/tmux/manager/sessions - Create a new session
+ */
+tmuxApi.post("/manager/sessions", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerCreateSessionSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.createSession(
+      validation.data.nodeId,
+      validation.data
+    );
+
+    if (result.success) {
+      const node = manager.getNode(validation.data.nodeId);
+      if (node) {
+        addActivity({
+          environmentId: node.id,
+          action: "tmux_session_created",
+          environmentName: node.name,
+          details: result.sessionName
+            ? `Session "${result.sessionName}" created`
+            : "Session created",
+        });
+      }
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * GET /api/tmux/manager/sessions - List all sessions
+ */
+tmuxApi.get("/manager/sessions", async (c) => {
+  try {
+    const manager = getTmuxManager();
+
+    // Parse query parameters
+    const nodeIds = c.req.queries()["nodeIds"];
+    const tags = c.req.queries()["tags"];
+    const detailed = c.req.query("detailed") === "true";
+    const includeInactive = c.req.query("includeInactive") === "true";
+
+    const sessions = await manager.listSessions({
+      nodeIds,
+      tags,
+      detailed,
+      includeInactive,
+    });
+
+    return c.json({ success: true, sessions });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/attach - Attach to a session
+ */
+tmuxApi.post("/manager/sessions/attach", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerAttachSessionSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.attachSession(
+      validation.data.nodeId,
+      validation.data.sessionName
+    );
+
+    if (result.success) {
+      const node = manager.getNode(validation.data.nodeId);
+      if (node) {
+        addActivity({
+          environmentId: node.id,
+          action: "tmux_session_attached",
+          environmentName: node.name,
+          details: `Attached to session "${result.sessionName}"`,
+        });
+      }
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * DELETE /api/tmux/manager/sessions - Kill a session
+ */
+tmuxApi.delete("/manager/sessions", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerKillSessionSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.killSession(
+      validation.data.nodeId,
+      validation.data.sessionName
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_session_killed",
+        environmentName: node.name,
+        details: `Session "${validation.data.sessionName}" killed`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+// ============================================
+// Command Execution
+// ============================================
+
+/**
+ * POST /api/tmux/manager/sessions/command - Send command to a session
+ */
+tmuxApi.post("/manager/sessions/command", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerSendCommandSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.sendCommand(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.command,
+      validation.data.paneIndex
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_command_sent",
+        environmentName: node.name,
+        details: `Command: ${validation.data.command.slice(0, 100)}${validation.data.command.length > 100 ? "..." : ""}`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/command/batch - Send command to multiple nodes
+ */
+tmuxApi.post("/manager/sessions/command/batch", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerBatchSendCommandSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result: BatchOperationResult = await manager.sendCommandToNodes(
+      validation.data.nodeIds,
+      validation.data.sessionName,
+      validation.data.command,
+      {
+        paneIndex: validation.data.paneIndex,
+        parallel: validation.data.parallel,
+        continueOnError: validation.data.continueOnError,
+        timeout: validation.data.timeout,
+      }
+    );
+
+    // Log activity per node
+    for (const r of result.results) {
+      if (r.success) {
+        const node = manager.getNode(r.nodeId);
+        if (node) {
+          addActivity({
+            environmentId: node.id,
+            action: "tmux_batch_command_sent",
+            environmentName: node.name,
+            details: `Batch command to ${result.total} nodes: ${validation.data.command.slice(0, 80)}${validation.data.command.length > 80 ? "..." : ""}`,
+          });
+        }
+      }
+    }
+
+    return c.json({ success: true, result });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+// ============================================
+// Pane Operations
+// ============================================
+
+/**
+ * POST /api/tmux/manager/sessions/split - Split a pane
+ */
+tmuxApi.post("/manager/sessions/split", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerSplitPaneSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.splitPaneOnNode(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.direction,
+      validation.data.command,
+      validation.data.windowIndex
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_pane_split",
+        environmentName: node.name,
+        details: `Split pane ${validation.data.direction === "h" ? "horizontally" : "vertically"}${validation.data.command ? ` with command: ${validation.data.command.slice(0, 50)}...` : ""}`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/capture - Capture pane output
+ */
+tmuxApi.post("/manager/sessions/capture", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerCapturePaneSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.capturePaneOutput(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.paneIndex
+    );
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/history - Get pane history
+ */
+tmuxApi.post("/manager/sessions/history", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerGetHistorySchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.getPaneHistory(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.paneIndex,
+      validation.data.lines
+    );
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * DELETE /api/tmux/manager/sessions/pane - Kill a pane
+ */
+tmuxApi.delete("/manager/sessions/pane", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerKillPaneSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.killPaneInSession(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.paneIndex
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_pane_killed",
+        environmentName: node.name,
+        details: `Pane ${validation.data.paneIndex} killed in session "${validation.data.sessionName}"`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+// ============================================
+// Window Operations
+// ============================================
+
+/**
+ * POST /api/tmux/manager/sessions/windows - List windows in a session
+ */
+tmuxApi.post("/manager/sessions/windows", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerListWindowsSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.listWindows(
+      validation.data.nodeId,
+      validation.data.sessionName
+    );
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/panes - List panes in a window
+ */
+tmuxApi.post("/manager/sessions/panes", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerListPanesSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.listPanes(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.windowIndex
+    );
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/windows/switch - Switch to a window
+ */
+tmuxApi.post("/manager/sessions/windows/switch", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerSwitchWindowSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.switchToWindow(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.windowIndex
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_window_switched",
+        environmentName: node.name,
+        details: `Switched to window ${validation.data.windowIndex} in session "${validation.data.sessionName}"`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/panes/switch - Switch to a pane
+ */
+tmuxApi.post("/manager/sessions/panes/switch", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerSwitchPaneSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.switchToPane(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.paneIndex
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_pane_switched",
+        environmentName: node.name,
+        details: `Switched to pane ${validation.data.paneIndex} in session "${validation.data.sessionName}"`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * PUT /api/tmux/manager/sessions/windows/rename - Rename a window
+ */
+tmuxApi.put("/manager/sessions/windows/rename", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerRenameWindowSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.renameWindowInSession(
+      validation.data.nodeId,
+      validation.data.sessionName,
+      validation.data.windowIndex,
+      validation.data.newName
+    );
+
+    if (result.success && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_window_renamed",
+        environmentName: node.name,
+        details: `Renamed window ${validation.data.windowIndex} to "${validation.data.newName}" in session "${validation.data.sessionName}"`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+// ============================================
+// Maintenance & Monitoring
+// ============================================
+
+/**
+ * GET /api/tmux/manager/sessions/detailed - Get detailed session info
+ */
+tmuxApi.get("/manager/sessions/detailed", async (c) => {
+  const nodeId = c.req.query("nodeId");
+  const sessionName = c.req.query("sessionName");
+
+  if (!nodeId || !sessionName) {
+    return c.json({ success: false, error: "nodeId and sessionName are required" }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.getDetailedSession(nodeId, sessionName);
+    return c.json({ success: result !== null, session: result });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/sessions/cleanup - Cleanup old sessions
+ */
+tmuxApi.post("/manager/sessions/cleanup", async (c) => {
+  const body = await c.req.json();
+  const validation = validateRequest(TmuxManagerCleanupOldSessionsSchema, body);
+
+  if (!validation.success) {
+    return c.json({ success: false, error: validation.error }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const node = manager.getNode(validation.data.nodeId);
+    const result = await manager.cleanupOldSessions(
+      validation.data.nodeId,
+      validation.data.ageLimitMs
+    );
+
+    if (result.success && result.cleaned && result.cleaned > 0 && node) {
+      addActivity({
+        environmentId: node.id,
+        action: "tmux_sessions_cleaned",
+        environmentName: node.name,
+        details: `Cleaned up ${result.cleaned} old tmux sessions`,
+      });
+    }
+
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * GET /api/tmux/manager/nodes/:id/resources - Get resource usage for a node
+ */
+tmuxApi.get("/manager/nodes/:id/resources", async (c) => {
+  const id = c.req.param("id");
+  if (!id) {
+    return c.json({ success: false, error: "Node ID is required" }, 400);
+  }
+
+  try {
+    const manager = getTmuxManager();
+    const result = await manager.getResourceUsage(id);
+    return c.json(result);
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * GET /api/tmux/manager/summary - Get summary statistics
+ */
+tmuxApi.get("/manager/summary", async (c) => {
+  try {
+    const manager = getTmuxManager();
+    const summary = await manager.getSummary();
+    return c.json({ success: true, summary });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+/**
+ * POST /api/tmux/manager/cache/invalidate - Invalidate session cache
+ */
+tmuxApi.post("/manager/cache/invalidate", async (c) => {
+  try {
+    const manager = getTmuxManager();
+    const body = await c.req.json().catch(() => ({}));
+    const nodeId = body?.nodeId;
+    manager.invalidateCache(nodeId);
+    return c.json({ success: true });
+  } catch (error) {
+    return c.json({ success: false, error: String(error) }, 500);
+  }
+});
+
+export { tmuxApi };