mcp-remote 0.1.21 → 0.1.22

package/README.md

@@ -135,6 +135,24 @@ To bypass authentication, or to emit custom headers on all requests to your remo
       ]
 ```
 
+* To ignore specific tools from the remote server, add the `--ignore-tool` flag. This will filter out tools matching the specified patterns from both `tools/list` responses and block `tools/call` requests. Supports wildcard patterns with `*`.
+
+```json
+      "args": [
+        "mcp-remote",
+        "https://remote.mcp.server/sse",
+        "--ignore-tool",
+        "delete*",
+        "--ignore-tool",
+        "remove*"
+      ]
+```
+
+You can specify multiple `--ignore-tool` flags to ignore different patterns. Examples:
+- `delete*` - ignores all tools starting with "delete" (e.g., `deleteTask`, `deleteUser`)
+- `*account` - ignores all tools ending with "account" (e.g., `getAccount`, `updateAccount`)
+- `exactTool` - ignores only the tool named exactly "exactTool"
+
 ### Transport Strategies
 
 MCP Remote supports different transport strategies when connecting to an MCP server. This allows you to control whether it uses Server-Sent Events (SSE) or HTTP transport, and in what order it tries them.

package/dist/{chunk-BCWNEBAL.js → chunk-AVTRP4BV.js}

@@ -11872,7 +11872,7 @@ var Client = class extends Protocol {
 };
 
 // package.json
-var version = "0.1.21";
+var version = "0.1.22";
 
 // node_modules/.pnpm/pkce-challenge@5.0.0/node_modules/pkce-challenge/dist/index.node.js
 var crypto;
@@ -13679,11 +13679,75 @@ function log(str, ...rest) {
     debugLog(str, ...rest);
   }
 }
-function mcpProxy({ transportToClient, transportToServer }) {
+var MESSAGE_BLOCKED = Symbol("MessageBlocked");
+var isMessageBlocked = (value) => value === MESSAGE_BLOCKED;
+function createMessageTransformer({
+  transformRequestFunction,
+  transformResponseFunction
+} = {}) {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  const interceptRequest = (message) => {
+    const messageId = message.id;
+    if (!messageId) return message;
+    pendingRequests.set(messageId, message);
+    return transformRequestFunction?.(message) ?? message;
+  };
+  const interceptResponse = (message) => {
+    const messageId = message.id;
+    if (!messageId) return message;
+    const originalRequest = pendingRequests.get(messageId);
+    pendingRequests.delete(messageId);
+    return transformResponseFunction?.(originalRequest, message) ?? message;
+  };
+  return {
+    interceptRequest,
+    interceptResponse
+  };
+}
+function mcpProxy({
+  transportToClient,
+  transportToServer,
+  ignoredTools = []
+}) {
   let transportToClientClosed = false;
   let transportToServerClosed = false;
+  const messageTransformer = createMessageTransformer({
+    transformRequestFunction: (request) => {
+      if (request.method === "tools/call" && request.params?.name) {
+        const toolName = request.params.name;
+        if (!shouldIncludeTool(ignoredTools, toolName)) {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: request.id,
+            error: {
+              code: -32603,
+              message: `Tool "${toolName}" is not available`
+            }
+          };
+          transportToClient.send(errorResponse).catch(onClientError);
+          return MESSAGE_BLOCKED;
+        }
+      }
+      return request;
+    },
+    transformResponseFunction: (req, res) => {
+      if (req.method === "tools/list") {
+        return {
+          ...res,
+          result: {
+            ...res.result,
+            tools: res.result.tools.filter((tool) => shouldIncludeTool(ignoredTools, tool.name))
+          }
+        };
+      }
+      return res;
+    }
+  });
   transportToClient.onmessage = (_message) => {
-    const message = _message;
+    const message = messageTransformer.interceptRequest(_message);
+    if (isMessageBlocked(message)) {
+      return;
+    }
     log("[Local\u2192Remote]", message.method || message.id);
     if (DEBUG) {
       debugLog("Local \u2192 Remote message", {
@@ -13703,7 +13767,7 @@ function mcpProxy({ transportToClient, transportToServer }) {
     transportToServer.send(message).catch(onServerError);
   };
   transportToServer.onmessage = (_message) => {
-    const message = _message;
+    const message = messageTransformer.interceptResponse(_message);
     log("[Remote\u2192Local]", message.method || message.id);
     if (DEBUG) {
       debugLog("Remote \u2192 Local message", {
@@ -14045,6 +14109,18 @@ async function parseCommandLineArgs(args, usage) {
     authorizeResource = args[resourceIndex + 1];
     log(`Using authorize resource: ${authorizeResource}`);
   }
+  const ignoredTools = [];
+  let j = 0;
+  while (j < args.length) {
+    if (args[j] === "--ignore-tool" && j < args.length - 1) {
+      const toolName = args[j + 1];
+      ignoredTools.push(toolName);
+      log(`Ignoring tool: ${toolName}`);
+      args.splice(j, 2);
+      continue;
+    }
+    j++;
+  }
   if (!serverUrl) {
     log(usage);
     process.exit(1);
@@ -14104,7 +14180,8 @@ async function parseCommandLineArgs(args, usage) {
     debug,
     staticOAuthClientMetadata,
     staticOAuthClientInfo,
-    authorizeResource
+    authorizeResource,
+    ignoredTools
   };
 }
 function setupSignalHandlers(cleanup) {
@@ -14123,6 +14200,24 @@ function setupSignalHandlers(cleanup) {
 function getServerUrlHash(serverUrl) {
   return crypto2.createHash("md5").update(serverUrl).digest("hex");
 }
+function patternToRegex(pattern) {
+  const parts = pattern.split("*");
+  const escapedParts = parts.map((part) => part.replace(/\W/g, "\\$&"));
+  const regexPattern = escapedParts.join(".*");
+  return new RegExp(`^${regexPattern}$`, "i");
+}
+function shouldIncludeTool(ignorePatterns, toolName) {
+  if (!ignorePatterns || ignorePatterns.length === 0) {
+    return true;
+  }
+  for (const pattern of ignorePatterns) {
+    const regex = patternToRegex(pattern);
+    if (regex.test(toolName)) {
+      return false;
+    }
+  }
+  return true;
+}
 
 // src/lib/node-oauth-client-provider.ts
 import open from "open";

package/dist/client.js

@@ -11,7 +11,7 @@ import {
   parseCommandLineArgs,
   setupSignalHandlers,
   version
-} from "./chunk-BCWNEBAL.js";
+} from "./chunk-AVTRP4BV.js";
 
 // src/client.ts
 import { EventEmitter } from "events";

package/dist/proxy.js

@@ -9,7 +9,7 @@ import {
   mcpProxy,
   parseCommandLineArgs,
   setupSignalHandlers
-} from "./chunk-BCWNEBAL.js";
+} from "./chunk-AVTRP4BV.js";
 
 // src/proxy.ts
 import { EventEmitter } from "events";
@@ -110,7 +110,7 @@ var StdioServerTransport = class {
 };
 
 // src/proxy.ts
-async function runProxy(serverUrl, callbackPort, headers, transportStrategy = "http-first", host, staticOAuthClientMetadata, staticOAuthClientInfo, authorizeResource) {
+async function runProxy(serverUrl, callbackPort, headers, transportStrategy = "http-first", host, staticOAuthClientMetadata, staticOAuthClientInfo, authorizeResource, ignoredTools) {
   const events = new EventEmitter();
   const serverUrlHash = getServerUrlHash(serverUrl);
   const authCoordinator = createLazyAuthCoordinator(serverUrlHash, callbackPort, events);
@@ -141,7 +141,8 @@ async function runProxy(serverUrl, callbackPort, headers, transportStrategy = "h
     const remoteTransport = await connectToRemoteServer(null, serverUrl, authProvider, headers, authInitializer, transportStrategy);
     mcpProxy({
       transportToClient: localTransport,
-      transportToServer: remoteTransport
+      transportToServer: remoteTransport,
+      ignoredTools
     });
     await localTransport.start();
     log("Local STDIO server running");
@@ -195,7 +196,8 @@ parseCommandLineArgs(process.argv.slice(2), "Usage: npx tsx proxy.ts <https://se
     debug,
     staticOAuthClientMetadata,
     staticOAuthClientInfo,
-    authorizeResource
+    authorizeResource,
+    ignoredTools
   }) => {
     return runProxy(
       serverUrl,
@@ -205,7 +207,8 @@ parseCommandLineArgs(process.argv.slice(2), "Usage: npx tsx proxy.ts <https://se
       host,
       staticOAuthClientMetadata,
       staticOAuthClientInfo,
-      authorizeResource
+      authorizeResource,
+      ignoredTools
     );
   }
 ).catch((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-remote",
-  "version": "0.1.21",
+  "version": "0.1.22",
   "description": "Remote proxy for Model Context Protocol, allowing local-only clients to connect to remote servers using oAuth",
   "keywords": [
     "mcp",