@ebowwa/terminal 0.2.0

package/src/mcp/stdio.ts

@@ -0,0 +1,708 @@
+#!/usr/bin/env bun
+/**
+ * Terminal MCP Server (stdio protocol)
+ *
+ * Model Context Protocol server for terminal session management
+ * Uses stdio transport for Claude Code integration
+ */
+
+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 Protocol Types
+//=============
+
+interface JSONRPCMessage {
+  jsonrpc: "2.0";
+  id?: number | string;
+  method?: string;
+  params?: any;
+  result?: any;
+  error?: {
+    code: number;
+    message: string;
+    data?: any;
+  };
+}
+
+interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, {
+      type: string;
+      description: string;
+      enum?: string[];
+    }>;
+    required: string[];
+  };
+}
+
+// ==============
+// Tool Implementations
+//=============
+
+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");
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+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}`);
+  }
+}
+
+async function getActiveConnectionsTool(): Promise<string> {
+  try {
+    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}`);
+  }
+}
+
+// ==============
+// Tool Definitions
+//=============
+
+const TOOLS: MCPTool[] = [
+  {
+    name: "list_sessions",
+    description: "List all active terminal sessions",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "get_session_info",
+    description: "Get detailed information about a specific terminal session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "The session ID to get info for",
+        },
+      },
+      required: ["session_id"],
+    },
+  },
+  {
+    name: "create_session",
+    description: "Create a new terminal session (SSH or PTY)",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host in format user@host or just host",
+        },
+        type: {
+          type: "string",
+          description: "Session type: ssh or pty",
+          enum: ["ssh", "pty"],
+        },
+        command: {
+          type: "string",
+          description: "Optional command to run on session creation",
+        },
+      },
+      required: ["host"],
+    },
+  },
+  {
+    name: "write_command",
+    description: "Write a command to an active terminal session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "The session ID to write to",
+        },
+        command: {
+          type: "string",
+          description: "The command to write to the session",
+        },
+      },
+      required: ["session_id", "command"],
+    },
+  },
+  {
+    name: "resize_session",
+    description: "Resize a terminal session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "The session ID to resize",
+        },
+        rows: {
+          type: "number",
+          description: "Number of rows",
+        },
+        cols: {
+          type: "number",
+          description: "Number of columns",
+        },
+      },
+      required: ["session_id", "rows", "cols"],
+    },
+  },
+  {
+    name: "close_session",
+    description: "Close a terminal session",
+    inputSchema: {
+      type: "object",
+      properties: {
+        session_id: {
+          type: "string",
+          description: "The session ID to close",
+        },
+      },
+      required: ["session_id"],
+    },
+  },
+  {
+    name: "exec_ssh",
+    description: "Execute a command via SSH",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host in format user@host or just host",
+        },
+        command: {
+          type: "string",
+          description: "The command to execute",
+        },
+      },
+      required: ["host", "command"],
+    },
+  },
+  {
+    name: "test_connection",
+    description: "Test SSH connection to a host",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host to test connection to",
+        },
+      },
+      required: ["host"],
+    },
+  },
+  {
+    name: "list_tmux_sessions",
+    description: "List all tmux sessions",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+  {
+    name: "list_files",
+    description: "List files on a remote host",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host to list files on",
+        },
+        path: {
+          type: "string",
+          description: "Path to list (default: current directory)",
+        },
+      },
+      required: ["host"],
+    },
+  },
+  {
+    name: "upload_file",
+    description: "Upload a file via SCP",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host to upload to",
+        },
+        local_path: {
+          type: "string",
+          description: "Local file path to upload",
+        },
+        remote_path: {
+          type: "string",
+          description: "Remote destination path",
+        },
+      },
+      required: ["host", "local_path", "remote_path"],
+    },
+  },
+  {
+    name: "download_file",
+    description: "Download a file via SCP",
+    inputSchema: {
+      type: "object",
+      properties: {
+        host: {
+          type: "string",
+          description: "SSH host to download from",
+        },
+        remote_path: {
+          type: "string",
+          description: "Remote file path to download",
+        },
+        local_path: {
+          type: "string",
+          description: "Local destination path",
+        },
+      },
+      required: ["host", "remote_path", "local_path"],
+    },
+  },
+  {
+    name: "get_active_connections",
+    description: "Get all active SSH connections",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+];
+
+// ==============
+// MCP Server
+//=============
+
+async function handleToolCall(name: string, args: any): Promise<string> {
+  switch (name) {
+    case "list_sessions":
+      return await listSessionsTool();
+    case "get_session_info":
+      return await getSessionInfoTool(args.session_id);
+    case "create_session":
+      return await createSessionTool(args.host, args.type, args.command);
+    case "write_command":
+      return await writeCommandTool(args.session_id, args.command);
+    case "resize_session":
+      return await resizeSessionTool(args.session_id, args.rows, args.cols);
+    case "close_session":
+      return await closeSessionTool(args.session_id);
+    case "exec_ssh":
+      return await execSSHTool(args.host, args.command, args.options);
+    case "test_connection":
+      return await testConnection(args.host);
+    case "list_tmux_sessions":
+      return await listTmuxSessionsTool();
+    case "list_files":
+      return await listFilesTool(args.host, args.path);
+    case "upload_file":
+      return await uploadFileTool(args.host, args.local_path, args.remote_path);
+    case "download_file":
+      return await downloadFileTool(args.host, args.remote_path, args.local_path);
+    case "get_active_connections":
+      return await getActiveConnectionsTool();
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+function sendMessage(message: JSONRPCMessage): void {
+  console.log(JSON.stringify(message));
+}
+
+async function processMessage(message: JSONRPCMessage): Promise<void> {
+  const { id, method, params } = message;
+
+  try {
+    switch (method) {
+      case "initialize":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {},
+            },
+            serverInfo: {
+              name: "terminal-mcp",
+              version: "1.0.0",
+            },
+          },
+        });
+        break;
+
+      case "tools/list":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            tools: TOOLS,
+          },
+        });
+        break;
+
+      case "tools/call":
+        const { name, arguments: args } = params;
+        const result = await handleToolCall(name, args || {});
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [
+              {
+                type: "text",
+                text: result,
+              },
+            ],
+          },
+        });
+        break;
+
+      case "shutdown":
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          result: {},
+        });
+        process.exit(0);
+        break;
+
+      default:
+        sendMessage({
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method not found: ${method}`,
+          },
+        });
+    }
+  } catch (error) {
+    sendMessage({
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: -32603,
+        message: `Internal error: ${error}`,
+      },
+    });
+  }
+}
+
+// ==============
+// Main Loop
+//=============
+
+async function main() {
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  for await (const chunk of process.stdin) {
+    buffer += decoder.decode(chunk);
+
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const message: JSONRPCMessage = JSON.parse(line);
+        await processMessage(message);
+      } catch (error) {
+        sendMessage({
+          jsonrpc: "2.0",
+          error: {
+            code: -32700,
+            message: `Parse error: ${error}`,
+          },
+        });
+      }
+    }
+  }
+}
+
+main().catch(console.error);