wip sse

Author: zhjch05

src/client.ts

@@ -3,7 +3,9 @@ import {
   StdioClientTransport,
   StdioServerParameters,
 } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
 import { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import { ServerParameters } from "./fetch-metamcp.js";
 
 const sleep = (time: number) =>
   new Promise<void>((resolve) => setTimeout(() => resolve(), time));
@@ -13,9 +15,27 @@ export interface ConnectedClient {
 }
 
 export const createMetaMcpClient = (
-  serverParams: StdioServerParameters
+  serverParams: ServerParameters
 ): { client: Client | undefined; transport: Transport | undefined } => {
-  const transport = new StdioClientTransport(serverParams);
+  let transport: Transport | undefined;
+
+  // Create the appropriate transport based on server type
+  if (serverParams.type === "STDIO") {
+    const stdioParams: StdioServerParameters = {
+      command: serverParams.command || "",
+      args: serverParams.args || undefined,
+      env: serverParams.env || undefined,
+      // Use default values for other optional properties
+      // stderr and cwd will use their default values
+    };
+    transport = new StdioClientTransport(stdioParams);
+  } else if (serverParams.type === "SSE" && serverParams.url) {
+    transport = new SSEClientTransport(new URL(serverParams.url));
+  } else {
+    console.error(`Unsupported server type: ${serverParams.type}`);
+    return { client: undefined, transport: undefined };
+  }
+
   const client = new Client(
     {
       name: "MetaMCP",

src/fetch-metamcp.ts

@@ -1,18 +1,34 @@
 import axios from "axios";
 import { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import {
   getDefaultEnvironment,
   getMetaMcpApiBaseUrl,
   getMetaMcpApiKey,
 } from "./utils.js";
 
-let _mcpServersCache: Record<string, StdioServerParameters> | null = null;
+// Define a new interface for server parameters that can be either STDIO or SSE
+export interface ServerParameters {
+  uuid: string;
+  name: string;
+  description: string;
+  type: "STDIO" | "SSE";
+  command?: string | null;
+  args?: string[] | null;
+  env?: Record<string, string> | null;
+  url?: string | null;
+  created_at: string;
+  profile_uuid: string;
+  status: string;
+}
+
+let _mcpServersCache: Record<string, ServerParameters> | null = null;
 let _mcpServersCacheTimestamp: number = 0;
 const CACHE_TTL_MS = 1000; // 1 second cache TTL
 
 export async function getMcpServers(
   forceRefresh: boolean = false
-): Promise<Record<string, StdioServerParameters>> {
+): Promise<Record<string, ServerParameters>> {
   const currentTime = Date.now();
   const cacheAge = currentTime - _mcpServersCacheTimestamp;
 
@@ -40,27 +56,29 @@ export async function getMcpServers(
     });
     const data = response.data;
 
-    const serverDict: Record<string, StdioServerParameters> = {};
+    const serverDict: Record<string, ServerParameters> = {};
     for (const params of data) {
-      if ("args" in params && !params.args) {
-        params.args = undefined;
-      }
+      // Process based on server type
+      if (params.type === "STDIO") {
+        if ("args" in params && !params.args) {
+          params.args = undefined;
+        }
 
-      params.env = {
-        ...getDefaultEnvironment(),
-        ...(params.env || {}),
-      };
-
-      const serverParams: StdioServerParameters = {
-        ...params,
-        env: {
+        params.env = {
           ...getDefaultEnvironment(),
           ...(params.env || {}),
-        },
-      };
+        };
+      } else if (params.type === "SSE") {
+        // For SSE servers, ensure url is present
+        if (!params.url) {
+          console.warn(`SSE server ${params.uuid} is missing url field, skipping`);
+          continue;
+        }
+      }
+
       const uuid = params.uuid;
       if (uuid) {
-        serverDict[uuid] = serverParams;
+        serverDict[uuid] = params;
       }
     }
 

src/sessions.ts

@@ -1,4 +1,5 @@
 import { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ServerParameters } from "./fetch-metamcp.js";
 import {
   ConnectedClient,
   createMetaMcpClient,
@@ -10,7 +11,7 @@ const _sessions: Record<string, ConnectedClient> = {};
 export const getSession = async (
   sessionKey: string,
   uuid: string,
-  params: StdioServerParameters
+  params: ServerParameters
 ): Promise<ConnectedClient | undefined> => {
   if (sessionKey in _sessions) {
     return _sessions[sessionKey];

src/utils.ts

@@ -1,4 +1,5 @@
 import { StdioServerParameters } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { ServerParameters } from "./fetch-metamcp.js";
 import crypto from "crypto";
 
 /**
@@ -64,27 +65,40 @@ export function sanitizeName(name: string): string {
 }
 
 export function computeParamsHash(
-  params: StdioServerParameters,
+  params: ServerParameters,
   uuid: string
 ): string {
-  const paramsDict = {
-    uuid,
-    command: params.command,
-    args: params.args,
-    env: params.env
-      ? Object.fromEntries(
-          Object.entries(params.env).sort((a, b) => a[0].localeCompare(b[0]))
-        )
-      : null,
-  };
+  let paramsDict: any;
+
+  if (params.type === "STDIO") {
+    paramsDict = {
+      uuid,
+      type: params.type,
+      command: params.command,
+      args: params.args,
+      env: params.env
+        ? Object.fromEntries(
+            Object.entries(params.env).sort((a, b) => a[0].localeCompare(b[0]))
+          )
+        : null,
+    };
+  } else if (params.type === "SSE") {
+    paramsDict = {
+      uuid,
+      type: params.type,
+      url: params.url,
+    };
+  } else {
+    throw new Error(`Unsupported server type: ${params.type}`);
+  }
 
   const paramsJson = JSON.stringify(paramsDict);
   return crypto.createHash("sha256").update(paramsJson).digest("hex");
 }
 
 export function getSessionKey(
   uuid: string,
-  params: StdioServerParameters
+  params: ServerParameters
 ): string {
   return `${uuid}_${computeParamsHash(params, uuid)}`;
 }