mcp-remote 0.0.1 → 0.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cloudflare, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# `mcp-remote`
+
+**EXPERIMENTAL PROOF OF CONCEPT**
+
+Connect an MCP Client that only supports local (stdio) servers to a Remote MCP Server, with auth support:
+
+E.g: Claude Desktop or Windsurf
+
+```json
+{
+  "mcpServers": {
+    "remote-example": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "https://remote.mcp.server/sse"
+      ]
+    }
+  }
+}
+```
+
+Cursor:
+
+![image](https://github.com/user-attachments/assets/14338bfa-a779-4e8a-a477-71f72cc5d99d)
+

package/dist/chunk-SB5B4PZV.js

@@ -0,0 +1,326 @@
+// src/shared.ts
+import express from "express";
+import open from "open";
+import fs from "fs/promises";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+import net from "net";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import {
+  OAuthClientInformationSchema,
+  OAuthTokensSchema
+} from "@modelcontextprotocol/sdk/shared/auth.js";
+var NodeOAuthClientProvider = class {
+  /**
+   * Creates a new NodeOAuthClientProvider
+   * @param options Configuration options for the provider
+   */
+  constructor(options) {
+    this.options = options;
+    this.serverUrlHash = crypto.createHash("md5").update(options.serverUrl).digest("hex");
+    this.configDir = options.configDir || path.join(os.homedir(), ".mcp-auth");
+    this.callbackPath = options.callbackPath || "/oauth/callback";
+    this.clientName = options.clientName || "MCP CLI Client";
+    this.clientUri = options.clientUri || "https://github.com/modelcontextprotocol/mcp-cli";
+  }
+  configDir;
+  serverUrlHash;
+  callbackPath;
+  clientName;
+  clientUri;
+  get redirectUrl() {
+    return `http://localhost:${this.options.callbackPort}${this.callbackPath}`;
+  }
+  get clientMetadata() {
+    return {
+      redirect_uris: [this.redirectUrl],
+      token_endpoint_auth_method: "none",
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      client_name: this.clientName,
+      client_uri: this.clientUri
+    };
+  }
+  /**
+   * Ensures the configuration directory exists
+   * @private
+   */
+  async ensureConfigDir() {
+    try {
+      await fs.mkdir(this.configDir, { recursive: true });
+    } catch (error) {
+      console.error("Error creating config directory:", error);
+      throw error;
+    }
+  }
+  /**
+   * Reads a JSON file and parses it with the provided schema
+   * @param filename The name of the file to read
+   * @param schema The schema to validate against
+   * @returns The parsed file content or undefined if the file doesn't exist
+   * @private
+   */
+  async readFile(filename, schema) {
+    try {
+      await this.ensureConfigDir();
+      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`);
+      const content = await fs.readFile(filePath, "utf-8");
+      return await schema.parseAsync(JSON.parse(content));
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return void 0;
+      }
+      return void 0;
+    }
+  }
+  /**
+   * Writes a JSON object to a file
+   * @param filename The name of the file to write
+   * @param data The data to write
+   * @private
+   */
+  async writeFile(filename, data) {
+    try {
+      await this.ensureConfigDir();
+      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`);
+      await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+    } catch (error) {
+      console.error(`Error writing ${filename}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Writes a text string to a file
+   * @param filename The name of the file to write
+   * @param text The text to write
+   * @private
+   */
+  async writeTextFile(filename, text) {
+    try {
+      await this.ensureConfigDir();
+      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`);
+      await fs.writeFile(filePath, text, "utf-8");
+    } catch (error) {
+      console.error(`Error writing ${filename}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Reads text from a file
+   * @param filename The name of the file to read
+   * @returns The file content as a string
+   * @private
+   */
+  async readTextFile(filename) {
+    try {
+      await this.ensureConfigDir();
+      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`);
+      return await fs.readFile(filePath, "utf-8");
+    } catch (error) {
+      throw new Error("No code verifier saved for session");
+    }
+  }
+  /**
+   * Gets the client information if it exists
+   * @returns The client information or undefined
+   */
+  async clientInformation() {
+    return this.readFile("client_info.json", OAuthClientInformationSchema);
+  }
+  /**
+   * Saves client information
+   * @param clientInformation The client information to save
+   */
+  async saveClientInformation(clientInformation) {
+    await this.writeFile("client_info.json", clientInformation);
+  }
+  /**
+   * Gets the OAuth tokens if they exist
+   * @returns The OAuth tokens or undefined
+   */
+  async tokens() {
+    return this.readFile("tokens.json", OAuthTokensSchema);
+  }
+  /**
+   * Saves OAuth tokens
+   * @param tokens The tokens to save
+   */
+  async saveTokens(tokens) {
+    await this.writeFile("tokens.json", tokens);
+  }
+  /**
+   * Redirects the user to the authorization URL
+   * @param authorizationUrl The URL to redirect to
+   */
+  async redirectToAuthorization(authorizationUrl) {
+    console.error(`
+Please authorize this client by visiting:
+${authorizationUrl.toString()}
+`);
+    try {
+      await open(authorizationUrl.toString());
+      console.error("Browser opened automatically.");
+    } catch (error) {
+      console.error("Could not open browser automatically. Please copy and paste the URL above into your browser.");
+    }
+  }
+  /**
+   * Saves the PKCE code verifier
+   * @param codeVerifier The code verifier to save
+   */
+  async saveCodeVerifier(codeVerifier) {
+    await this.writeTextFile("code_verifier.txt", codeVerifier);
+  }
+  /**
+   * Gets the PKCE code verifier
+   * @returns The code verifier
+   */
+  async codeVerifier() {
+    return await this.readTextFile("code_verifier.txt");
+  }
+};
+function setupOAuthCallbackServer(options) {
+  let authCode = null;
+  const app = express();
+  app.get(options.path, (req, res) => {
+    const code = req.query.code;
+    if (!code) {
+      res.status(400).send("Error: No authorization code received");
+      return;
+    }
+    authCode = code;
+    res.send("Authorization successful! You may close this window and return to the CLI.");
+    options.events.emit("auth-code-received", code);
+  });
+  const server = app.listen(options.port, () => {
+    console.error(`OAuth callback server running at http://localhost:${options.port}`);
+  });
+  const waitForAuthCode = () => {
+    return new Promise((resolve) => {
+      if (authCode) {
+        resolve(authCode);
+        return;
+      }
+      options.events.once("auth-code-received", (code) => {
+        resolve(code);
+      });
+    });
+  };
+  return { server, authCode, waitForAuthCode };
+}
+async function connectToRemoteServer(serverUrl, authProvider, waitForAuthCode) {
+  console.error("Connecting to remote server:", serverUrl);
+  const url = new URL(serverUrl);
+  const transport = new SSEClientTransport(url, { authProvider });
+  try {
+    await transport.start();
+    console.error("Connected to remote server");
+    return transport;
+  } catch (error) {
+    if (error instanceof UnauthorizedError || error instanceof Error && error.message.includes("Unauthorized")) {
+      console.error("Authentication required. Waiting for authorization...");
+      const code = await waitForAuthCode();
+      try {
+        console.error("Completing authorization...");
+        await transport.finishAuth(code);
+        const newTransport = new SSEClientTransport(url, { authProvider });
+        await newTransport.start();
+        console.error("Connected to remote server after authentication");
+        return newTransport;
+      } catch (authError) {
+        console.error("Authorization error:", authError);
+        throw authError;
+      }
+    } else {
+      console.error("Connection error:", error);
+      throw error;
+    }
+  }
+}
+function mcpProxy({ transportToClient, transportToServer }) {
+  let transportToClientClosed = false;
+  let transportToServerClosed = false;
+  transportToClient.onmessage = (message) => {
+    console.error("[Local\u2192Remote]", message.method || message.id);
+    transportToServer.send(message).catch(onServerError);
+  };
+  transportToServer.onmessage = (message) => {
+    console.error("[Remote\u2192Local]", message.method || message.id);
+    transportToClient.send(message).catch(onClientError);
+  };
+  transportToClient.onclose = () => {
+    if (transportToServerClosed) {
+      return;
+    }
+    transportToClientClosed = true;
+    transportToServer.close().catch(onServerError);
+  };
+  transportToServer.onclose = () => {
+    if (transportToClientClosed) {
+      return;
+    }
+    transportToServerClosed = true;
+    transportToClient.close().catch(onClientError);
+  };
+  transportToClient.onerror = onClientError;
+  transportToServer.onerror = onServerError;
+  function onClientError(error) {
+    console.error("Error from local client:", error);
+  }
+  function onServerError(error) {
+    console.error("Error from remote server:", error);
+  }
+}
+async function findAvailablePort(preferredPort) {
+  return new Promise((resolve, reject) => {
+    const server = net.createServer();
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        server.listen(0);
+      } else {
+        reject(err);
+      }
+    });
+    server.on("listening", () => {
+      const { port } = server.address();
+      server.close(() => {
+        resolve(port);
+      });
+    });
+    server.listen(preferredPort || 0);
+  });
+}
+async function parseCommandLineArgs(args, defaultPort, usage) {
+  const serverUrl = args[0];
+  const specifiedPort = args[1] ? parseInt(args[1]) : void 0;
+  if (!serverUrl || !serverUrl.startsWith("https://")) {
+    console.error(usage);
+    process.exit(1);
+  }
+  const callbackPort = specifiedPort || await findAvailablePort(defaultPort);
+  if (specifiedPort) {
+    console.error(`Using specified callback port: ${callbackPort}`);
+  } else {
+    console.error(`Using automatically selected callback port: ${callbackPort}`);
+  }
+  return { serverUrl, callbackPort };
+}
+function setupSignalHandlers(cleanup) {
+  process.on("SIGINT", async () => {
+    console.error("\nShutting down...");
+    await cleanup();
+    process.exit(0);
+  });
+  process.stdin.resume();
+}
+
+export {
+  NodeOAuthClientProvider,
+  setupOAuthCallbackServer,
+  connectToRemoteServer,
+  mcpProxy,
+  parseCommandLineArgs,
+  setupSignalHandlers
+};

package/dist/client.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/client.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  NodeOAuthClientProvider,
+  parseCommandLineArgs,
+  setupOAuthCallbackServer,
+  setupSignalHandlers
+} from "./chunk-SB5B4PZV.js";
+
+// src/client.ts
+import { EventEmitter } from "events";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { ListResourcesResultSchema, ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+async function runClient(serverUrl, callbackPort) {
+  const events = new EventEmitter();
+  const authProvider = new NodeOAuthClientProvider({
+    serverUrl,
+    callbackPort,
+    clientName: "MCP CLI Client"
+  });
+  const client = new Client(
+    {
+      name: "mcp-cli",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        sampling: {}
+      }
+    }
+  );
+  const url = new URL(serverUrl);
+  function initTransport() {
+    const transport2 = new SSEClientTransport(url, { authProvider });
+    transport2.onmessage = (message) => {
+      console.log("Received message:", JSON.stringify(message, null, 2));
+    };
+    transport2.onerror = (error) => {
+      console.error("Transport error:", error);
+    };
+    transport2.onclose = () => {
+      console.log("Connection closed.");
+      process.exit(0);
+    };
+    return transport2;
+  }
+  const transport = initTransport();
+  const { server, waitForAuthCode } = setupOAuthCallbackServer({
+    port: callbackPort,
+    path: "/oauth/callback",
+    events
+  });
+  const cleanup = async () => {
+    console.log("\nClosing connection...");
+    await client.close();
+    server.close();
+  };
+  setupSignalHandlers(cleanup);
+  try {
+    console.log("Connecting to server...");
+    await client.connect(transport);
+    console.log("Connected successfully!");
+  } catch (error) {
+    if (error instanceof UnauthorizedError || error instanceof Error && error.message.includes("Unauthorized")) {
+      console.log("Authentication required. Waiting for authorization...");
+      const code = await waitForAuthCode();
+      try {
+        console.log("Completing authorization...");
+        await transport.finishAuth(code);
+        console.log("Connecting after authorization...");
+        await client.connect(initTransport());
+        console.log("Connected successfully!");
+        console.log("Requesting tools list...");
+        const tools = await client.request({ method: "tools/list" }, ListToolsResultSchema);
+        console.log("Tools:", JSON.stringify(tools, null, 2));
+        console.log("Requesting resource list...");
+        const resources = await client.request({ method: "resources/list" }, ListResourcesResultSchema);
+        console.log("Resources:", JSON.stringify(resources, null, 2));
+        console.log("Listening for messages. Press Ctrl+C to exit.");
+      } catch (authError) {
+        console.error("Authorization error:", authError);
+        server.close();
+        process.exit(1);
+      }
+    } else {
+      console.error("Connection error:", error);
+      server.close();
+      process.exit(1);
+    }
+  }
+  try {
+    console.log("Requesting tools list...");
+    const tools = await client.request({ method: "tools/list" }, ListToolsResultSchema);
+    console.log("Tools:", JSON.stringify(tools, null, 2));
+  } catch (e) {
+    console.log("Error requesting tools list:", e);
+  }
+  try {
+    console.log("Requesting resource list...");
+    const resources = await client.request({ method: "resources/list" }, ListResourcesResultSchema);
+    console.log("Resources:", JSON.stringify(resources, null, 2));
+  } catch (e) {
+    console.log("Error requesting resources list:", e);
+  }
+  console.log("Listening for messages. Press Ctrl+C to exit.");
+}
+parseCommandLineArgs(process.argv.slice(2), 3333, "Usage: npx tsx client.ts <https://server-url> [callback-port]").then(({ serverUrl, callbackPort }) => {
+  return runClient(serverUrl, callbackPort);
+}).catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/dist/proxy.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/proxy.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import {
+  NodeOAuthClientProvider,
+  connectToRemoteServer,
+  mcpProxy,
+  parseCommandLineArgs,
+  setupOAuthCallbackServer,
+  setupSignalHandlers
+} from "./chunk-SB5B4PZV.js";
+
+// src/proxy.ts
+import { EventEmitter } from "events";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function runProxy(serverUrl, callbackPort) {
+  const events = new EventEmitter();
+  const authProvider = new NodeOAuthClientProvider({
+    serverUrl,
+    callbackPort,
+    clientName: "MCP CLI Proxy"
+  });
+  const localTransport = new StdioServerTransport();
+  const { server, waitForAuthCode } = setupOAuthCallbackServer({
+    port: callbackPort,
+    path: "/oauth/callback",
+    events
+  });
+  try {
+    const remoteTransport = await connectToRemoteServer(serverUrl, authProvider, waitForAuthCode);
+    mcpProxy({
+      transportToClient: localTransport,
+      transportToServer: remoteTransport
+    });
+    await localTransport.start();
+    console.error("Local STDIO server running");
+    console.error("Proxy established successfully between local STDIO and remote SSE");
+    console.error("Press Ctrl+C to exit");
+    const cleanup = async () => {
+      await remoteTransport.close();
+      await localTransport.close();
+      server.close();
+    };
+    setupSignalHandlers(cleanup);
+  } catch (error) {
+    console.error("Fatal error:", error);
+    server.close();
+    process.exit(1);
+  }
+}
+parseCommandLineArgs(process.argv.slice(2), 3334, "Usage: npx tsx proxy.ts <https://server-url> [callback-port]").then(({ serverUrl, callbackPort }) => {
+  return runProxy(serverUrl, callbackPort);
+}).catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -1,14 +1,27 @@
 {
   "name": "mcp-remote",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
-  "devDependencies": {
+  "bin": "dist/proxy.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup"
+  },
+  "dependencies": {
     "@modelcontextprotocol/sdk": "^1.7.0",
+    "express": "^4.21.2",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
     "@types/express": "^5.0.0",
     "@types/node": "^22.13.10",
-    "express": "^4.21.2",
-    "open": "^10.1.0",
     "prettier": "^3.5.3",
-    "tsx": "^4.19.3"
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.3",
+    "typescript": "^5.8.2"
   }
 }

package/.prettierrc

@@ -1,14 +0,0 @@
-{
-  "printWidth": 140,
-  "singleQuote": true,
-  "semi": false,
-  "useTabs": false,
-  "overrides": [
-    {
-      "files": ["*.jsonc"],
-      "options": {
-        "trailingComma": "none"
-      }
-    }
-  ]
-}

package/sse-auth-client.ts

@@ -1,307 +0,0 @@
-#!/usr/bin/env node
-
-// sse-auth-client.ts - MCP Client with OAuth support
-// Run with: npx tsx sse-auth-client.ts sse-auth-client.ts https://example.remote/server [callback-port]
-
-import express from 'express'
-import open from 'open'
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-import crypto from 'crypto'
-import { EventEmitter } from 'events'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
-import { OAuthClientProvider, auth, UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js'
-import { ListResourcesResultSchema, ListToolsResultSchema } from '@modelcontextprotocol/sdk/types.js'
-import {
-  OAuthClientInformation,
-  OAuthClientInformationFull,
-  OAuthClientInformationSchema,
-  OAuthTokens,
-  OAuthTokensSchema,
-} from '@modelcontextprotocol/sdk/shared/auth.js'
-
-// Implement OAuth client provider for Node.js environment
-class NodeOAuthClientProvider implements OAuthClientProvider {
-  private configDir: string
-  private serverUrlHash: string
-
-  constructor(
-    private serverUrl: string,
-    private callbackPort: number = 3333,
-    private callbackPath: string = '/oauth/callback',
-  ) {
-    this.serverUrlHash = crypto.createHash('md5').update(serverUrl).digest('hex')
-    this.configDir = path.join(os.homedir(), '.mcp-auth')
-  }
-
-  get redirectUrl(): string {
-    return `http://localhost:${this.callbackPort}${this.callbackPath}`
-  }
-
-  get clientMetadata() {
-    return {
-      redirect_uris: [this.redirectUrl],
-      token_endpoint_auth_method: 'none',
-      grant_types: ['authorization_code', 'refresh_token'],
-      response_types: ['code'],
-      client_name: 'MCP CLI Client',
-      client_uri: 'https://github.com/modelcontextprotocol/mcp-cli',
-    }
-  }
-
-  private async ensureConfigDir() {
-    try {
-      await fs.mkdir(this.configDir, { recursive: true })
-    } catch (error) {
-      console.error('Error creating config directory:', error)
-      throw error
-    }
-  }
-
-  private async readFile<T>(filename: string, schema: any): Promise<T | undefined> {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      const content = await fs.readFile(filePath, 'utf-8')
-      return await schema.parseAsync(JSON.parse(content))
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return undefined
-      }
-      return undefined
-    }
-  }
-
-  private async writeFile(filename: string, data: any) {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
-    } catch (error) {
-      console.error(`Error writing ${filename}:`, error)
-      throw error
-    }
-  }
-
-  private async writeTextFile(filename: string, text: string) {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      await fs.writeFile(filePath, text, 'utf-8')
-    } catch (error) {
-      console.error(`Error writing ${filename}:`, error)
-      throw error
-    }
-  }
-
-  private async readTextFile(filename: string): Promise<string> {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      return await fs.readFile(filePath, 'utf-8')
-    } catch (error) {
-      throw new Error('No code verifier saved for session')
-    }
-  }
-
-  async clientInformation(): Promise<OAuthClientInformation | undefined> {
-    return this.readFile<OAuthClientInformation>('client_info.json', OAuthClientInformationSchema)
-  }
-
-  async saveClientInformation(clientInformation: OAuthClientInformationFull): Promise<void> {
-    await this.writeFile('client_info.json', clientInformation)
-  }
-
-  async tokens(): Promise<OAuthTokens | undefined> {
-    return this.readFile<OAuthTokens>('tokens.json', OAuthTokensSchema)
-  }
-
-  async saveTokens(tokens: OAuthTokens): Promise<void> {
-    await this.writeFile('tokens.json', tokens)
-  }
-
-  async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
-    console.log(`\nPlease authorize this client by visiting:\n${authorizationUrl.toString()}\n`)
-    try {
-      await open(authorizationUrl.toString())
-      console.log('Browser opened automatically.')
-    } catch (error) {
-      console.log('Could not open browser automatically. Please copy and paste the URL above into your browser.')
-    }
-  }
-
-  async saveCodeVerifier(codeVerifier: string): Promise<void> {
-    await this.writeTextFile('code_verifier.txt', codeVerifier)
-  }
-
-  async codeVerifier(): Promise<string> {
-    return await this.readTextFile('code_verifier.txt')
-  }
-}
-
-// Main function to run the client
-async function runClient(serverUrl: string, callbackPort: number) {
-  // Set up event emitter for auth flow
-  const events = new EventEmitter()
-
-  // Create the OAuth client provider
-  const authProvider = new NodeOAuthClientProvider(serverUrl, callbackPort)
-
-  // Create the client
-  const client = new Client(
-    {
-      name: 'mcp-cli',
-      version: '0.1.0',
-    },
-    {
-      capabilities: {
-        sampling: {},
-      },
-    },
-  )
-
-  // Create the transport
-  const url = new URL(serverUrl)
-
-  function initTransport() {
-    const transport = new SSEClientTransport(url, { authProvider })
-
-    // Set up message and error handlers
-    transport.onmessage = (message) => {
-      console.log('Received message:', JSON.stringify(message, null, 2))
-    }
-
-    transport.onerror = (error) => {
-      console.error('Transport error:', error)
-    }
-
-    transport.onclose = () => {
-      console.log('Connection closed.')
-      process.exit(0)
-    }
-    return transport
-  }
-
-  const transport = initTransport()
-
-  // Set up an HTTP server to handle OAuth callback
-  let authCode: string | null = null
-  const app = express()
-
-  app.get('/oauth/callback', (req, res) => {
-    const code = req.query.code as string | undefined
-    if (!code) {
-      res.status(400).send('Error: No authorization code received')
-      return
-    }
-
-    authCode = code
-    res.send('Authorization successful! You may close this window and return to the CLI.')
-
-    // Notify main flow that auth code is available
-    events.emit('auth-code-received', code)
-  })
-
-  const server = app.listen(callbackPort, () => {
-    console.log(`OAuth callback server running at http://localhost:${callbackPort}`)
-  })
-
-  // Function to wait for auth code
-  const waitForAuthCode = (): Promise<string> => {
-    return new Promise((resolve) => {
-      if (authCode) {
-        resolve(authCode)
-        return
-      }
-
-      events.once('auth-code-received', (code) => {
-        resolve(code)
-      })
-    })
-  }
-
-  // Try to connect
-  try {
-    console.log('Connecting to server...')
-    await client.connect(transport)
-    console.log('Connected successfully!')
-
-    // Send a resources/list request
-    // console.log("Requesting resource list...");
-    // const result = await client.request({ method: "resources/list" }, ListResourcesResultSchema);
-    // console.log("Resources:", JSON.stringify(result, null, 2));
-
-    console.log('Request tools list...')
-    const tools = await client.request({ method: 'tools/list' }, ListToolsResultSchema)
-    console.log('Tools:', JSON.stringify(tools, null, 2))
-
-    console.log('Listening for messages. Press Ctrl+C to exit.')
-  } catch (error) {
-    if (error instanceof UnauthorizedError || (error instanceof Error && error.message.includes('Unauthorized'))) {
-      console.log('Authentication required. Waiting for authorization...')
-
-      // Wait for the authorization code from the callback
-      const code = await waitForAuthCode()
-
-      try {
-        console.log('Completing authorization...')
-        await transport.finishAuth(code)
-
-        // Start a new transport here? Ok cause it's going to write to the file maybe?
-
-        // Reconnect after authorization
-        console.log('Connecting after authorization...')
-        await client.connect(initTransport())
-
-        console.log('Connected successfully!')
-
-        // // Send a resources/list request
-        // console.log("Requesting resource list...");
-        // const result = await client.request({ method: "resources/list" }, ListResourcesResultSchema);
-        // console.log("Resources:", JSON.stringify(result, null, 2));2));
-
-        console.log('Request tools list...')
-        const tools = await client.request({ method: 'tools/list' }, ListToolsResultSchema)
-        console.log('Tools:', JSON.stringify(tools, null, 2))
-
-        console.log('Listening for messages. Press Ctrl+C to exit.')
-      } catch (authError) {
-        console.error('Authorization error:', authError)
-        server.close()
-        process.exit(1)
-      }
-    } else {
-      console.error('Connection error:', error)
-      server.close()
-      process.exit(1)
-    }
-  }
-
-  // Handle shutdown
-  process.on('SIGINT', async () => {
-    console.log('\nClosing connection...')
-    await client.close()
-    server.close()
-    process.exit(0)
-  })
-
-  // Keep the process alive
-  process.stdin.resume()
-}
-
-// Parse command-line arguments
-const args = process.argv.slice(2)
-const serverUrl = args[0]
-const callbackPort = args[1] ? parseInt(args[1]) : 3333
-
-if (!serverUrl || !serverUrl.startsWith('https://')) {
-  console.error('Usage: node --experimental-strip-types sse-auth-client.ts <https://server-url> [callback-port]')
-  process.exit(1)
-}
-
-runClient(serverUrl, callbackPort).catch((error) => {
-  console.error('Fatal error:', error)
-  process.exit(1)
-})

package/sse-auth-proxy.ts

@@ -1,323 +0,0 @@
-#!/usr/bin/env node
-
-// sse-auth-proxy.ts - MCP Proxy with OAuth support
-// Run with: npx tsx sse-auth-proxy.ts https://example.remote/server [callback-port]
-
-import express from 'express'
-import open from 'open'
-import fs from 'fs/promises'
-import path from 'path'
-import crypto from 'crypto'
-import { EventEmitter } from 'events'
-import { Server } from '@modelcontextprotocol/sdk/server/index.js'
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'
-import { OAuthClientProvider, auth, UnauthorizedError } from '@modelcontextprotocol/sdk/client/auth.js'
-import {
-  OAuthClientInformation,
-  OAuthClientInformationFull,
-  OAuthClientInformationSchema,
-  OAuthTokens,
-  OAuthTokensSchema,
-} from '@modelcontextprotocol/sdk/shared/auth.js'
-import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
-import os from 'os'
-
-// Implement OAuth client provider for Node.js environment
-class NodeOAuthClientProvider implements OAuthClientProvider {
-  private configDir: string
-  private serverUrlHash: string
-
-  constructor(
-    private serverUrl: string,
-    private callbackPort: number = 3334,
-    private callbackPath: string = '/oauth/callback',
-  ) {
-    this.serverUrlHash = crypto.createHash('md5').update(serverUrl).digest('hex')
-    this.configDir = path.join(os.homedir(), '.mcp-auth')
-  }
-
-  get redirectUrl(): string {
-    return `http://localhost:${this.callbackPort}${this.callbackPath}`
-  }
-
-  get clientMetadata() {
-    return {
-      redirect_uris: [this.redirectUrl],
-      token_endpoint_auth_method: 'none',
-      grant_types: ['authorization_code', 'refresh_token'],
-      response_types: ['code'],
-      client_name: 'MCP CLI Proxy',
-      client_uri: 'https://github.com/modelcontextprotocol/mcp-cli',
-    }
-  }
-
-  private async ensureConfigDir() {
-    try {
-      await fs.mkdir(this.configDir, { recursive: true })
-    } catch (error) {
-      console.error('Error creating config directory:', error)
-      throw error
-    }
-  }
-
-  private async readFile<T>(filename: string, schema: any): Promise<T | undefined> {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      const content = await fs.readFile(filePath, 'utf-8')
-      return await schema.parseAsync(JSON.parse(content))
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return undefined
-      }
-      return undefined
-    }
-  }
-
-  private async writeFile(filename: string, data: any) {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
-    } catch (error) {
-      console.error(`Error writing ${filename}:`, error)
-      throw error
-    }
-  }
-
-  private async writeTextFile(filename: string, text: string) {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      await fs.writeFile(filePath, text, 'utf-8')
-    } catch (error) {
-      console.error(`Error writing ${filename}:`, error)
-      throw error
-    }
-  }
-
-  private async readTextFile(filename: string): Promise<string> {
-    try {
-      await this.ensureConfigDir()
-      const filePath = path.join(this.configDir, `${this.serverUrlHash}_${filename}`)
-      return await fs.readFile(filePath, 'utf-8')
-    } catch (error) {
-      throw new Error('No code verifier saved for session')
-    }
-  }
-
-  async clientInformation(): Promise<OAuthClientInformation | undefined> {
-    return this.readFile<OAuthClientInformation>('client_info.json', OAuthClientInformationSchema)
-  }
-
-  async saveClientInformation(clientInformation: OAuthClientInformationFull): Promise<void> {
-    await this.writeFile('client_info.json', clientInformation)
-  }
-
-  async tokens(): Promise<OAuthTokens | undefined> {
-    return this.readFile<OAuthTokens>('tokens.json', OAuthTokensSchema)
-  }
-
-  async saveTokens(tokens: OAuthTokens): Promise<void> {
-    await this.writeFile('tokens.json', tokens)
-  }
-
-  async redirectToAuthorization(authorizationUrl: URL): Promise<void> {
-    console.error(`\nPlease authorize this client by visiting:\n${authorizationUrl.toString()}\n`)
-    try {
-      await open(authorizationUrl.toString())
-      console.error('Browser opened automatically.')
-    } catch (error) {
-      console.error('Could not open browser automatically. Please copy and paste the URL above into your browser.')
-    }
-  }
-
-  async saveCodeVerifier(codeVerifier: string): Promise<void> {
-    await this.writeTextFile('code_verifier.txt', codeVerifier)
-  }
-
-  async codeVerifier(): Promise<string> {
-    return await this.readTextFile('code_verifier.txt')
-  }
-}
-
-// Function to proxy messages between two transports
-function mcpProxy({ transportToClient, transportToServer }: { transportToClient: Transport; transportToServer: Transport }) {
-  let transportToClientClosed = false
-  let transportToServerClosed = false
-
-  transportToClient.onmessage = (message) => {
-    console.error('[Local→Remote]', message.method || message.id)
-    transportToServer.send(message).catch(onServerError)
-  }
-
-  transportToServer.onmessage = (message) => {
-    console.error('[Remote→Local]', message.method || message.id)
-    transportToClient.send(message).catch(onClientError)
-  }
-
-  transportToClient.onclose = () => {
-    if (transportToServerClosed) {
-      return
-    }
-
-    transportToClientClosed = true
-    transportToServer.close().catch(onServerError)
-  }
-
-  transportToServer.onclose = () => {
-    if (transportToClientClosed) {
-      return
-    }
-    transportToServerClosed = true
-    transportToClient.close().catch(onClientError)
-  }
-
-  transportToClient.onerror = onClientError
-  transportToServer.onerror = onServerError
-
-  function onClientError(error: Error) {
-    console.error('Error from local client:', error)
-  }
-
-  function onServerError(error: Error) {
-    console.error('Error from remote server:', error)
-  }
-}
-
-// Main function to run the proxy
-async function runProxy(serverUrl: string, callbackPort: number) {
-  // Set up event emitter for auth flow
-  const events = new EventEmitter()
-
-  // Create the OAuth client provider
-  const authProvider = new NodeOAuthClientProvider(serverUrl, callbackPort)
-
-  // Create the STDIO transport
-  const localTransport = new StdioServerTransport()
-
-  // Set up an HTTP server to handle OAuth callback
-  let authCode: string | null = null
-  const app = express()
-
-  app.get('/oauth/callback', (req, res) => {
-    const code = req.query.code as string | undefined
-    if (!code) {
-      res.status(400).send('Error: No authorization code received')
-      return
-    }
-
-    authCode = code
-    res.send('Authorization successful! You may close this window and return to the CLI.')
-
-    // Notify main flow that auth code is available
-    events.emit('auth-code-received', code)
-  })
-
-  const httpServer = app.listen(callbackPort, () => {
-    console.error(`OAuth callback server running at http://localhost:${callbackPort}`)
-  })
-
-  // Function to wait for auth code
-  const waitForAuthCode = (): Promise<string> => {
-    return new Promise((resolve) => {
-      if (authCode) {
-        resolve(authCode)
-        return
-      }
-
-      events.once('auth-code-received', (code) => {
-        resolve(code)
-      })
-    })
-  }
-
-  // Function to create and connect to remote server, handling auth
-  const connectToRemoteServer = async (): Promise<SSEClientTransport> => {
-    console.error('Connecting to remote server:', serverUrl)
-    const url = new URL(serverUrl)
-    const transport = new SSEClientTransport(url, { authProvider })
-
-    try {
-      await transport.start()
-      console.error('Connected to remote server')
-      return transport
-    } catch (error) {
-      if (error instanceof UnauthorizedError || (error instanceof Error && error.message.includes('Unauthorized'))) {
-        console.error('Authentication required. Waiting for authorization...')
-
-        // Wait for the authorization code from the callback
-        const code = await waitForAuthCode()
-
-        try {
-          console.error('Completing authorization...')
-          await transport.finishAuth(code)
-
-          // Create a new transport after auth
-          const newTransport = new SSEClientTransport(url, { authProvider })
-          await newTransport.start()
-          console.error('Connected to remote server after authentication')
-          return newTransport
-        } catch (authError) {
-          console.error('Authorization error:', authError)
-          throw authError
-        }
-      } else {
-        console.error('Connection error:', error)
-        throw error
-      }
-    }
-  }
-
-  try {
-    // Start local server
-    // await server.connect(serverTransport)
-
-    // Connect to remote server
-    const remoteTransport = await connectToRemoteServer()
-
-    // Set up bidirectional proxy
-    mcpProxy({
-      transportToClient: localTransport,
-      transportToServer: remoteTransport,
-    })
-
-    await localTransport.start()
-    console.error('Local STDIO server running')
-
-    console.error('Proxy established successfully')
-    console.error('Press Ctrl+C to exit')
-
-    // Handle shutdown
-    process.on('SIGINT', async () => {
-      console.error('\nShutting down proxy...')
-      await remoteTransport.close()
-      await localTransport.close()
-      httpServer.close()
-      process.exit(0)
-    })
-
-    // Keep the process alive
-    process.stdin.resume()
-  } catch (error) {
-    console.error('Fatal error:', error)
-    httpServer.close()
-    process.exit(1)
-  }
-}
-
-// Parse command-line arguments
-const args = process.argv.slice(2)
-const serverUrl = args[0]
-const callbackPort = args[1] ? parseInt(args[1]) : 3334
-
-if (!serverUrl || !serverUrl.startsWith('https://')) {
-  console.error('Usage: npx tsx sse-auth-proxy.ts <https://server-url> [callback-port]')
-  process.exit(1)
-}
-
-runProxy(serverUrl, callbackPort).catch((error) => {
-  console.error('Fatal error:', error)
-  process.exit(1)
-})

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "outDir": "./build",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "lib": ["ES2022"],
-    "types": ["node"],
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true
-  },
-  "include": ["*.ts","src/**/*"],
-  "exclude": ["node_modules", "packages", "**/*.spec.ts"]
-}