@ebowwa/terminal 0.2.0

package/src/mcp/index.ts

@@ -0,0 +1,467 @@
+#!/usr/bin/env bun
+/**
+ * Terminal MCP Server
+ *
+ * Exposes terminal session management via Model Context Protocol
+ * Integrates with tmux, SSH, PTY, and file operations
+ */
+
+import type {
+  TerminalSession,
+  SessionInfo,
+  SSHOptions,
+  SCPOptions,
+} from "../index.js";
+
+// Re-export terminal functions
+import {
+  // Session management
+  getOrCreateSession,
+  getSession,
+  getAllSessions,
+  getAllSessionInfo,
+  getSessionInfo,
+  closeSession,
+  cleanupStaleSessions,
+  getSessionsByHost,
+  writeToSession,
+  resizeSession,
+  getSessionCount,
+
+  // PTY operations
+  createPTYSession,
+  writeToPTY,
+  setPTYSize,
+  readFromPTY,
+  closePTYSession,
+  getPTYSession,
+  getActivePTYSessions,
+
+  // Tmux operations
+  generateSessionName,
+  isTmuxInstalled,
+  ensureTmux,
+  listTmuxSessions,
+  hasTmuxSession,
+  createOrAttachTmuxSession,
+  killTmuxSession,
+  getTmuxSessionInfo,
+  cleanupOldTmuxSessions,
+  getTmuxResourceUsage,
+  sendCommandToPane,
+  splitPane,
+  capturePane,
+  getPaneHistory,
+  switchWindow,
+  switchPane,
+  renameWindow,
+  killPane,
+  getDetailedSessionInfo,
+  listSessionWindows,
+  listWindowPanes,
+
+  // SSH operations
+  execSSH,
+  execSSHParallel,
+  testSSHConnection,
+
+  // SCP operations
+  scpUpload,
+  scpDownload,
+
+  // File operations
+  listFiles,
+  previewFile,
+  sanitizePath,
+
+  // Fingerprint operations
+  getSSHFingerprint,
+  getLocalKeyFingerprint,
+  testSSHKeyConnection,
+
+  // Connection pool
+  getSSHPool,
+  closeGlobalSSHPool,
+  getActiveSSHConnections,
+} from "../index.js";
+
+// ==============
+// MCP Tools
+//=============
+
+/**
+ * List all active terminal sessions
+ */
+async function listSessionsTool(): Promise<string> {
+  const sessions = getAllSessionInfo();
+  const lines = [
+    "🖥️  Active Terminal Sessions",
+    "=" .repeat(50),
+    "",
+    `Total sessions: ${sessions.length}`,
+    "",
+  ];
+
+  for (const session of sessions) {
+    const active = session.active ? "🟢" : "⚪";
+    lines.push(`${active} ${session.id}`);
+    lines.push(`    Host: ${session.host}`);
+    lines.push(`    Type: ${session.type}`);
+    lines.push(`    Created: ${new Date(session.createdAt).toLocaleString()}`);
+    if (session.lastActivity) {
+      lines.push(`    Last activity: ${new Date(session.lastActivity).toLocaleString()}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Get detailed info about a specific session
+ */
+async function getSessionInfoTool(sessionId: string): Promise<string> {
+  try {
+    const info = await getSessionInfo(sessionId);
+    const lines = [
+      `📋 Session: ${sessionId}`,
+      "=" .repeat(50),
+      "",
+      `Host: ${info.host}`,
+      `Type: ${info.type}`,
+      `Active: ${info.active ? "Yes" : "No"}`,
+      `Created: ${new Date(info.createdAt).toLocaleString()}`,
+    ];
+
+    if (info.lastActivity) {
+      lines.push(`Last activity: ${new Date(info.lastActivity).toLocaleString()}`);
+    }
+
+    const session = getSession(sessionId);
+    if (session) {
+      lines.push(``);
+      lines.push(`PTY session: ${session.ptyId || "N/A"}`);
+      lines.push(`WebSocket attached: ${session.wsAttached ? "Yes" : "No"}`);
+    }
+
+    return lines.join("\n");
+  } catch (error) {
+    throw new Error(`Failed to get session info: ${error}`);
+  }
+}
+
+/**
+ * Create a new terminal session
+ */
+async function createSessionTool(host: string, type: "ssh" | "pty" = "ssh", command?: string): Promise<string> {
+  try {
+    const session = await getOrCreateSession(host, {
+      type,
+      command,
+    });
+
+    return `✓ Created session ${session.id} for ${host} (${type})`;
+  } catch (error) {
+    throw new Error(`Failed to create session: ${error}`);
+  }
+}
+
+/**
+ * Write a command to a session
+ */
+async function writeCommandTool(sessionId: string, command: string): Promise<string> {
+  try {
+    const session = getSession(sessionId);
+    if (!session) {
+      throw new Error(`Session ${sessionId} not found`);
+    }
+
+    await writeToSession(sessionId, command);
+    return `✓ Command sent to session ${sessionId}`;
+  } catch (error) {
+    throw new Error(`Failed to write command: ${error}`);
+  }
+}
+
+/**
+ * Resize a session
+ */
+async function resizeSessionTool(sessionId: string, rows: number, cols: number): Promise<string> {
+  try {
+    await resizeSession(sessionId, rows, cols);
+    return `✓ Resized session ${sessionId} to ${rows}x${cols}`;
+  } catch (error) {
+    throw new Error(`Failed to resize session: ${error}`);
+  }
+}
+
+/**
+ * Close a session
+ */
+async function closeSessionTool(sessionId: string): Promise<string> {
+  try {
+    await closeSession(sessionId);
+    return `✓ Closed session ${sessionId}`;
+  } catch (error) {
+    throw new Error(`Failed to close session: ${error}`);
+  }
+}
+
+/**
+ * Execute a command via SSH
+ */
+async function execSSHTool(host: string, command: string, options?: Partial<SSHOptions>): Promise<string> {
+  try {
+    const result = await execSSH(host, command, options);
+    return result.stdout || result.stderr || "Command executed";
+  } catch (error) {
+    throw new Error(`SSH command failed: ${error}`);
+  }
+}
+
+/**
+ * Test SSH connection
+ */
+async function testConnectionTool(host: string): Promise<string> {
+  try {
+    const result = await testSSHConnection(host);
+    if (result.success) {
+      return `✓ Connection to ${host} successful\nLatency: ${result.latency}ms`;
+    } else {
+      throw new Error(result.error || "Connection failed");
+    }
+  } catch (error) {
+    throw new Error(`Connection test failed: ${error}`);
+  }
+}
+
+/**
+ * List tmux sessions
+ */
+async function listTmuxSessionsTool(): Promise<string> {
+  try {
+    await ensureTmux();
+    const sessions = await listTmuxSessions();
+    const lines = [
+      "🎬 Tmux Sessions",
+      "=" .repeat(50),
+      "",
+    ];
+
+    if (sessions.length === 0) {
+      lines.push("No active tmux sessions");
+    } else {
+      for (const session of sessions) {
+        lines.push(`${session.name}`);
+        lines.push(`    Windows: ${session.windows}`);
+        lines.push(`    Created: ${new Date(session.created).toLocaleString()}`);
+        lines.push("");
+      }
+    }
+
+    return lines.join("\n");
+  } catch (error) {
+    throw new Error(`Failed to list tmux sessions: ${error}`);
+  }
+}
+
+/**
+ * List files on remote host
+ */
+async function listFilesTool(host: string, path: string = "."): Promise<string> {
+  try {
+    const files = await listFiles(host, path);
+    const lines = [
+      `📁 Files on ${host}:${path}`,
+      "=" .repeat(50),
+      "",
+    ];
+
+    for (const file of files) {
+      const icon = file.type === "directory" ? "📁" : "📄";
+      const size = file.size ? ` (${file.size} bytes)` : "";
+      lines.push(`${icon} ${file.name}${size}`);
+    }
+
+    return lines.join("\n");
+  } catch (error) {
+    throw new Error(`Failed to list files: ${error}`);
+  }
+}
+
+/**
+ * Upload file via SCP
+ */
+async function uploadFileTool(host: string, localPath: string, remotePath: string): Promise<string> {
+  try {
+    await scpUpload(host, { localPath, remotePath });
+    return `✓ Uploaded ${localPath} to ${host}:${remotePath}`;
+  } catch (error) {
+    throw new Error(`SCP upload failed: ${error}`);
+  }
+}
+
+/**
+ * Download file via SCP
+ */
+async function downloadFileTool(host: string, remotePath: string, localPath: string): Promise<string> {
+  try {
+    await scpDownload(host, { remotePath, localPath });
+    return `✓ Downloaded ${host}:${remotePath} to ${localPath}`;
+  } catch (error) {
+    throw new Error(`SCP download failed: ${error}`);
+  }
+}
+
+/**
+ * Get active SSH connections
+ */
+async function getActiveConnectionsTool(): Promise<string> {
+  try {
+    const pool = getSSHPool();
+    const connections = getActiveSSHConnections();
+    const lines = [
+      "🔗 Active SSH Connections",
+      "=" .repeat(50),
+      "",
+      `Total connections: ${connections.length}`,
+      "",
+    ];
+
+    for (const conn of connections) {
+      lines.push(`${conn.host}`);
+      lines.push(`    Connected: ${conn.connected ? "Yes" : "No"}`);
+      lines.push(`    Port: ${conn.port || 22}`);
+      lines.push("");
+    }
+
+    return lines.join("\n");
+  } catch (error) {
+    throw new Error(`Failed to get connections: ${error}`);
+  }
+}
+
+// ==============
+// MCP Server
+//=============
+
+const MCP_PORT = parseInt(process.env.MCP_PORT || "8913");
+
+Bun.serve({
+  port: MCP_PORT,
+  fetch: async (req) => {
+    const url = new URL(req.url);
+
+    // Health check
+    if (url.pathname === "/health") {
+      return Response.json({ status: "ok", port: MCP_PORT, service: "terminal-mcp" });
+    }
+
+    // MCP endpoint
+    if (url.pathname === "/mcp") {
+      if (req.method === "POST") {
+        const body = await req.json();
+        const { tool, args } = body;
+
+        try {
+          let result;
+
+          switch (tool) {
+            // Session management
+            case "list_sessions":
+              result = await listSessionsTool();
+              break;
+            case "get_session_info":
+              result = await getSessionInfoTool(args?.session_id);
+              break;
+            case "create_session":
+              result = await createSessionTool(args?.host, args?.type, args?.command);
+              break;
+            case "write_command":
+              result = await writeCommandTool(args?.session_id, args?.command);
+              break;
+            case "resize_session":
+              result = await resizeSessionTool(args?.session_id, args?.rows, args?.cols);
+              break;
+            case "close_session":
+              result = await closeSessionTool(args?.session_id);
+              break;
+
+            // SSH operations
+            case "exec_ssh":
+              result = await execSSHTool(args?.host, args?.command, args?.options);
+              break;
+            case "test_connection":
+              result = await testConnectionTool(args?.host);
+              break;
+
+            // Tmux operations
+            case "list_tmux_sessions":
+              result = await listTmuxSessionsTool();
+              break;
+
+            // File operations
+            case "list_files":
+              result = await listFilesTool(args?.host, args?.path);
+              break;
+            case "upload_file":
+              result = await uploadFileTool(args?.host, args?.local_path, args?.remote_path);
+              break;
+            case "download_file":
+              result = await downloadFileTool(args?.host, args?.remote_path, args?.local_path);
+              break;
+
+            // Connection management
+            case "get_active_connections":
+              result = await getActiveConnectionsTool();
+              break;
+
+            default:
+              return Response.json({ error: `Unknown tool: ${tool}` }, { status: 400 });
+          }
+
+          return Response.json({ result });
+        } catch (error) {
+          return Response.json({ error: String(error) }, { status: 500 });
+        }
+      }
+
+      // GET returns available tools
+      return Response.json({
+        name: "terminal-mcp",
+        version: "1.0.0",
+        description: "Terminal session management with tmux, SSH, PTY, and file operations",
+        tools: [
+          // Session management
+          { name: "list_sessions", description: "List all active terminal sessions" },
+          { name: "get_session_info", description: "Get detailed info about a session", args: ["session_id"] },
+          { name: "create_session", description: "Create a new terminal session", args: ["host", "type?", "command?"] },
+          { name: "write_command", description: "Write a command to a session", args: ["session_id", "command"] },
+          { name: "resize_session", description: "Resize a session terminal", args: ["session_id", "rows", "cols"] },
+          { name: "close_session", description: "Close a terminal session", args: ["session_id"] },
+
+          // SSH operations
+          { name: "exec_ssh", description: "Execute command via SSH", args: ["host", "command", "options?"] },
+          { name: "test_connection", description: "Test SSH connection", args: ["host"] },
+
+          // Tmux operations
+          { name: "list_tmux_sessions", description: "List all tmux sessions" },
+
+          // File operations
+          { name: "list_files", description: "List files on remote host", args: ["host", "path?"] },
+          { name: "upload_file", description: "Upload file via SCP", args: ["host", "local_path", "remote_path"] },
+          { name: "download_file", description: "Download file via SCP", args: ["host", "remote_path", "local_path"] },
+
+          // Connection management
+          { name: "get_active_connections", description: "Get active SSH connections" },
+        ]
+      });
+    }
+
+    return Response.json({ error: "Not found" }, { status: 404 });
+  },
+});
+
+console.log(`🚀 Terminal MCP Server running on port ${MCP_PORT}`);
+console.log(`   Health: http://localhost:${MCP_PORT}/health`);
+console.log(`   MCP:    http://localhost:${MCP_PORT}/mcp`);