@mcpfold/proxy 1.0.0

package/LICENSE

@@ -0,0 +1,28 @@
+MIT License
+
+Copyright (c) 2026 mcpfold contributors
+
+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.
+
+---
+
+The MIT license above covers the open-source packages: packages/* (@mcpfold/core,
+@mcpfold/adapters, @mcpfold/secrets, @mcpfold/proxy, @mcpfold/schema) and the `mcpfold`
+CLI. The cloud layer (apps/web, services/edge) is commercial/closed and NOT covered by
+this license.

package/dist/filter.d.ts

@@ -0,0 +1,14 @@
+import type { ToolsDirective } from '@mcpfold/core';
+/**
+ * Tool allow/deny filtering (S5.2). `mode: "allow"` keeps only listed tools; `mode: "deny"`
+ * removes listed tools. Order is preserved and surviving tool objects (schemas) are passed
+ * through untouched.
+ */
+export interface McpTool {
+    name: string;
+    [key: string]: unknown;
+}
+export declare function isToolAllowed(name: string, directive: ToolsDirective): boolean;
+/** Filter a tools array by the directive, preserving order and schemas. */
+export declare function filterTools<T extends McpTool>(tools: T[], directive: ToolsDirective): T[];
+//# sourceMappingURL=filter.d.ts.map

package/dist/filter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;;GAIG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,GAAG,OAAO,CAG9E;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,CAAC,SAAS,OAAO,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,cAAc,GAAG,CAAC,EAAE,CAEzF"}

package/dist/filter.js

@@ -0,0 +1,9 @@
+export function isToolAllowed(name, directive) {
+    const listed = directive.list.includes(name);
+    return directive.mode === 'allow' ? listed : !listed;
+}
+/** Filter a tools array by the directive, preserving order and schemas. */
+export function filterTools(tools, directive) {
+    return tools.filter((tool) => isToolAllowed(tool.name, directive));
+}
+//# sourceMappingURL=filter.js.map

package/dist/filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter.js","sourceRoot":"","sources":["../src/filter.ts"],"names":[],"mappings":"AAaA,MAAM,UAAU,aAAa,CAAC,IAAY,EAAE,SAAyB;IACnE,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC7C,OAAO,SAAS,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;AACvD,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,WAAW,CAAoB,KAAU,EAAE,SAAyB;IAClF,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;AACrE,CAAC"}

package/dist/handshake.d.ts

@@ -0,0 +1,20 @@
+import type { MessageTransport } from './transport/types.js';
+/**
+ * MCP initialize + tools/list handshake (S10.4) over any {@link MessageTransport}. Transport-
+ * agnostic — the CLI `test` command drives it over a spawned stdio process or an HTTP transport,
+ * and tests drive it over an in-memory mock. Confirms a server actually initializes and can list
+ * its tools, with a bounded per-request timeout so a hung server aborts cleanly (S0.9).
+ */
+export declare const MCP_PROTOCOL_VERSION = "2024-11-05";
+export interface HandshakeResult {
+    reachable: boolean;
+    protocolVersion?: string;
+    toolCount?: number;
+    /** Present when unreachable — a message safe to print (never the resolved token). */
+    error?: string;
+}
+export declare function handshake(transport: MessageTransport, opts?: {
+    timeoutMs?: number;
+    clientName?: string;
+}): Promise<HandshakeResult>;
+//# sourceMappingURL=handshake.d.ts.map

package/dist/handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.d.ts","sourceRoot":"","sources":["../src/handshake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D;;;;;GAKG;AAEH,eAAO,MAAM,oBAAoB,eAAe,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qFAAqF;IACrF,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAOD,wBAAsB,SAAS,CAC7B,SAAS,EAAE,gBAAgB,EAC3B,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAO,GACrD,OAAO,CAAC,eAAe,CAAC,CAwD1B"}

package/dist/handshake.js

@@ -0,0 +1,67 @@
+import { isResponse } from './jsonrpc.js';
+/**
+ * MCP initialize + tools/list handshake (S10.4) over any {@link MessageTransport}. Transport-
+ * agnostic — the CLI `test` command drives it over a spawned stdio process or an HTTP transport,
+ * and tests drive it over an in-memory mock. Confirms a server actually initializes and can list
+ * its tools, with a bounded per-request timeout so a hung server aborts cleanly (S0.9).
+ */
+export const MCP_PROTOCOL_VERSION = '2024-11-05';
+export async function handshake(transport, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? 10_000;
+    const pending = new Map();
+    transport.onMessage((msg) => {
+        if (!isResponse(msg) || msg.id == null)
+            return;
+        const p = pending.get(msg.id);
+        if (!p)
+            return;
+        pending.delete(msg.id);
+        if (msg.error)
+            p.reject(new Error(msg.error.message));
+        else
+            p.resolve(msg.result);
+    });
+    let nextId = 0;
+    const request = (method, params) => {
+        const id = ++nextId;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(id);
+                reject(new Error(`no response within ${timeoutMs}ms`));
+            }, timeoutMs);
+            pending.set(id, {
+                resolve: (v) => {
+                    clearTimeout(timer);
+                    resolve(v);
+                },
+                reject: (e) => {
+                    clearTimeout(timer);
+                    reject(e);
+                },
+            });
+            transport.send({ jsonrpc: '2.0', id, method, params });
+        });
+    };
+    try {
+        const init = (await request('initialize', {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: { name: opts.clientName ?? 'mcpfold', version: '1' },
+        }));
+        // MCP requires the client to confirm initialization before other requests.
+        transport.send({ jsonrpc: '2.0', method: 'notifications/initialized' });
+        const tools = (await request('tools/list', {}));
+        return {
+            reachable: true,
+            protocolVersion: init?.protocolVersion,
+            toolCount: Array.isArray(tools?.tools) ? tools.tools.length : 0,
+        };
+    }
+    catch (err) {
+        return { reachable: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        transport.close();
+    }
+}
+//# sourceMappingURL=handshake.js.map

package/dist/handshake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.js","sourceRoot":"","sources":["../src/handshake.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @mcpfold/proxy — the local MCP proxy for tool-level curation. Transparent passthrough
+ * (S5.1) plus tools/list allow/deny filtering (S5.2).
+ */
+export { parseMessage, serializeMessage, errorResponse, isRequest, isResponse, type JsonRpcError, type JsonRpcId, type JsonRpcMessage, } from './jsonrpc.js';
+export { connectProxy, type ProxyOptions } from './proxy.js';
+export { filterTools, isToolAllowed, type McpTool } from './filter.js';
+export { streamTransport } from './transport/stdio.js';
+export { MemoryTransport } from './transport/memory.js';
+export type { MessageTransport } from './transport/types.js';
+export { handshake, MCP_PROTOCOL_VERSION, type HandshakeResult } from './handshake.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,UAAU,EACV,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @mcpfold/proxy — the local MCP proxy for tool-level curation. Transparent passthrough
+ * (S5.1) plus tools/list allow/deny filtering (S5.2).
+ */
+export { parseMessage, serializeMessage, errorResponse, isRequest, isResponse, } from './jsonrpc.js';
+export { connectProxy } from './proxy.js';
+export { filterTools, isToolAllowed } from './filter.js';
+export { streamTransport } from './transport/stdio.js';
+export { MemoryTransport } from './transport/memory.js';
+export { handshake, MCP_PROTOCOL_VERSION } from './handshake.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,UAAU,GAIX,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,YAAY,EAAqB,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AACvE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,SAAS,EAAE,oBAAoB,EAAwB,MAAM,gBAAgB,CAAC"}

package/dist/jsonrpc.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Minimal JSON-RPC 2.0 message model + newline-delimited framing (MCP stdio transport).
+ * The proxy is transport-agnostic: it operates on {@link JsonRpcMessage} objects and lets
+ * transports handle framing.
+ */
+export type JsonRpcId = string | number | null;
+export interface JsonRpcError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export interface JsonRpcMessage {
+    jsonrpc: '2.0';
+    id?: JsonRpcId;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: JsonRpcError;
+}
+/** Parse one newline-delimited JSON message; returns null on malformed input. */
+export declare function parseMessage(line: string): JsonRpcMessage | null;
+/** Serialize a message with a trailing newline (MCP stdio framing). */
+export declare function serializeMessage(message: JsonRpcMessage): string;
+/** True if the message is a request carrying the given method. */
+export declare function isRequest(message: JsonRpcMessage, method?: string): boolean;
+/** True if the message is a response (has result or error) to a request id. */
+export declare function isResponse(message: JsonRpcMessage): boolean;
+/** Build a JSON-RPC error response for a request id. */
+export declare function errorResponse(id: JsonRpcId, error: JsonRpcError): JsonRpcMessage;
+//# sourceMappingURL=jsonrpc.d.ts.map

package/dist/jsonrpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"","sources":["../src/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE/C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,KAAK,CAAC;IACf,EAAE,CAAC,EAAE,SAAS,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAShE;AAED,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAEhE;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAG3E;AAED,+EAA+E;AAC/E,wBAAgB,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAE3D;AAED,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,YAAY,GAAG,cAAc,CAEhF"}

package/dist/jsonrpc.js

@@ -0,0 +1,37 @@
+/**
+ * Minimal JSON-RPC 2.0 message model + newline-delimited framing (MCP stdio transport).
+ * The proxy is transport-agnostic: it operates on {@link JsonRpcMessage} objects and lets
+ * transports handle framing.
+ */
+/** Parse one newline-delimited JSON message; returns null on malformed input. */
+export function parseMessage(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Serialize a message with a trailing newline (MCP stdio framing). */
+export function serializeMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+/** True if the message is a request carrying the given method. */
+export function isRequest(message, method) {
+    if (typeof message.method !== 'string')
+        return false;
+    return method === undefined ? true : message.method === method;
+}
+/** True if the message is a response (has result or error) to a request id. */
+export function isResponse(message) {
+    return message.id !== undefined && (message.result !== undefined || message.error !== undefined);
+}
+/** Build a JSON-RPC error response for a request id. */
+export function errorResponse(id, error) {
+    return { jsonrpc: '2.0', id, error };
+}
+//# sourceMappingURL=jsonrpc.js.map

package/dist/jsonrpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.js","sourceRoot":"","sources":["../src/jsonrpc.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmBH,iFAAiF;AACjF,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;IAC5B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAmB,CAAC;QACrD,OAAO,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,uEAAuE;AACvE,MAAM,UAAU,gBAAgB,CAAC,OAAuB;IACtD,OAAO,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;AACxC,CAAC;AAED,kEAAkE;AAClE,MAAM,UAAU,SAAS,CAAC,OAAuB,EAAE,MAAe;IAChE,IAAI,OAAO,OAAO,CAAC,MAAM,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACrD,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,KAAK,MAAM,CAAC;AACjE,CAAC;AAED,+EAA+E;AAC/E,MAAM,UAAU,UAAU,CAAC,OAAuB;IAChD,OAAO,OAAO,CAAC,EAAE,KAAK,SAAS,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC;AACnG,CAAC;AAED,wDAAwD;AACxD,MAAM,UAAU,aAAa,CAAC,EAAa,EAAE,KAAmB;IAC9D,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC;AACvC,CAAC"}

package/dist/proxy.d.ts

@@ -0,0 +1,13 @@
+import type { ToolsDirective } from '@mcpfold/core';
+import type { MessageTransport } from './transport/types.js';
+export interface ProxyOptions {
+    tools?: ToolsDirective;
+    /** Reject `tools/call` to a filtered-out tool instead of forwarding it. Default true. */
+    rejectFilteredCalls?: boolean;
+}
+/**
+ * Connect a client transport to a server transport, forwarding messages and applying the
+ * optional tools directive. Returns a disposer that closes both transports.
+ */
+export declare function connectProxy(client: MessageTransport, server: MessageTransport, options?: ProxyOptions): () => void;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAiB7D,MAAM,WAAW,YAAY;IAC3B,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,yFAAyF;IACzF,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAoBD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,gBAAgB,EACxB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,YAAiB,GACzB,MAAM,IAAI,CAkDZ"}

package/dist/proxy.js

@@ -0,0 +1,71 @@
+import { errorResponse, isRequest } from './jsonrpc.js';
+import { filterTools, isToolAllowed } from './filter.js';
+/**
+ * The mcpfold MCP proxy (S5.1 core + S5.2 filtering).
+ *
+ * Wires a client-side transport to a server-side transport and forwards every message
+ * faithfully in both directions (request ids, capabilities, notifications, and errors are
+ * preserved). When a `tools` directive is supplied it additionally:
+ *   - filters `tools/list` RESPONSES to the allow/deny set, and
+ *   - (optionally) rejects a `tools/call` to a filtered-out tool with a clear MCP error,
+ *     without forwarding it to the real server.
+ * With no directive it is a pure passthrough (S5.1). Opt-in; off by default.
+ */
+// MCP error code for "method/tool not found".
+const METHOD_NOT_FOUND = -32601;
+function isToolsResult(result) {
+    return (typeof result === 'object' &&
+        result !== null &&
+        Array.isArray(result.tools));
+}
+function callToolName(message) {
+    const params = message.params;
+    return typeof params?.name === 'string' ? params.name : undefined;
+}
+/**
+ * Connect a client transport to a server transport, forwarding messages and applying the
+ * optional tools directive. Returns a disposer that closes both transports.
+ */
+export function connectProxy(client, server, options = {}) {
+    const directive = options.tools;
+    const rejectFiltered = options.rejectFilteredCalls ?? true;
+    // Track which in-flight request ids were `tools/list` so we filter only their responses.
+    const pendingToolsList = new Set();
+    client.onMessage((message) => {
+        // Reject calls to filtered-out tools before they ever reach the real server.
+        if (directive &&
+            rejectFiltered &&
+            isRequest(message, 'tools/call') &&
+            message.id !== undefined) {
+            const name = callToolName(message);
+            if (name && !isToolAllowed(name, directive)) {
+                client.send(errorResponse(message.id, {
+                    code: METHOD_NOT_FOUND,
+                    message: `Tool "${name}" is not available (filtered by mcpfold).`,
+                }));
+                return;
+            }
+        }
+        if (directive && isRequest(message, 'tools/list') && message.id !== undefined) {
+            pendingToolsList.add(message.id);
+        }
+        server.send(message);
+    });
+    server.onMessage((message) => {
+        if (directive &&
+            message.id !== undefined &&
+            pendingToolsList.has(message.id) &&
+            isToolsResult(message.result)) {
+            pendingToolsList.delete(message.id);
+            const filtered = filterTools(message.result.tools, directive);
+            client.send({ ...message, result: { ...message.result, tools: filtered } });
+            return;
+        }
+        client.send(message);
+    });
+    return () => {
+        client.close();
+        server.close();
+    };
+}
+//# sourceMappingURL=proxy.js.map

package/dist/proxy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.js","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAuC,MAAM,cAAc,CAAC;AAC7F,OAAO,EAAE,WAAW,EAAE,aAAa,EAAgB,MAAM,aAAa,CAAC;AAGvE;;;;;;;;;;GAUG;AAEH,8CAA8C;AAC9C,MAAM,gBAAgB,GAAG,CAAC,KAAK,CAAC;AAahC,SAAS,aAAa,CAAC,MAAe;IACpC,OAAO,CACL,OAAO,MAAM,KAAK,QAAQ;QAC1B,MAAM,KAAK,IAAI;QACf,KAAK,CAAC,OAAO,CAAE,MAA8B,CAAC,KAAK,CAAC,CACrD,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,OAAuB;IAC3C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAwC,CAAC;IAChE,OAAO,OAAO,MAAM,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AACpE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAwB,EACxB,MAAwB,EACxB,UAAwB,EAAE;IAE1B,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC;IAChC,MAAM,cAAc,GAAG,OAAO,CAAC,mBAAmB,IAAI,IAAI,CAAC;IAC3D,yFAAyF;IACzF,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAAa,CAAC;IAE9C,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QAC3B,6EAA6E;QAC7E,IACE,SAAS;YACT,cAAc;YACd,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC;YAChC,OAAO,CAAC,EAAE,KAAK,SAAS,EACxB,CAAC;YACD,MAAM,IAAI,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;YACnC,IAAI,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;gBAC5C,MAAM,CAAC,IAAI,CACT,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE;oBACxB,IAAI,EAAE,gBAAgB;oBACtB,OAAO,EAAE,SAAS,IAAI,2CAA2C;iBAClE,CAAC,CACH,CAAC;gBACF,OAAO;YACT,CAAC;QACH,CAAC;QACD,IAAI,SAAS,IAAI,SAAS,CAAC,OAAO,EAAE,YAAY,CAAC,IAAI,OAAO,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;YAC9E,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QACnC,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QAC3B,IACE,SAAS;YACT,OAAO,CAAC,EAAE,KAAK,SAAS;YACxB,gBAAgB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,EAC7B,CAAC;YACD,gBAAgB,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;YACpC,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC9D,MAAM,CAAC,IAAI,CAAC,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,EAAE,CAAC,CAAC;YAC5E,OAAO;QACT,CAAC;QACD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,GAAG,EAAE;QACV,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,MAAM,CAAC,KAAK,EAAE,CAAC;IACjB,CAAC,CAAC;AACJ,CAAC"}

package/dist/transport/memory.d.ts

@@ -0,0 +1,17 @@
+import type { JsonRpcMessage } from '../jsonrpc.js';
+import type { MessageTransport } from './types.js';
+/**
+ * In-memory transport for tests: `receive()` simulates a message arriving from the peer, and
+ * `sent` records everything the proxy wrote toward the peer.
+ */
+export declare class MemoryTransport implements MessageTransport {
+    readonly sent: JsonRpcMessage[];
+    private handler?;
+    closed: boolean;
+    onMessage(handler: (message: JsonRpcMessage) => void): void;
+    send(message: JsonRpcMessage): void;
+    /** Simulate a message arriving from the peer (drives the proxy). */
+    receive(message: JsonRpcMessage): void;
+    close(): void;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/transport/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/transport/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;GAGG;AACH,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,QAAQ,CAAC,IAAI,EAAE,cAAc,EAAE,CAAM;IACrC,OAAO,CAAC,OAAO,CAAC,CAAoC;IACpD,MAAM,UAAS;IAEf,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,IAAI;IAI3D,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAInC,oEAAoE;IACpE,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAItC,KAAK,IAAI,IAAI;CAGd"}

package/dist/transport/memory.js

@@ -0,0 +1,23 @@
+/**
+ * In-memory transport for tests: `receive()` simulates a message arriving from the peer, and
+ * `sent` records everything the proxy wrote toward the peer.
+ */
+export class MemoryTransport {
+    sent = [];
+    handler;
+    closed = false;
+    onMessage(handler) {
+        this.handler = handler;
+    }
+    send(message) {
+        this.sent.push(message);
+    }
+    /** Simulate a message arriving from the peer (drives the proxy). */
+    receive(message) {
+        this.handler?.(message);
+    }
+    close() {
+        this.closed = true;
+    }
+}
+//# sourceMappingURL=memory.js.map

package/dist/transport/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/transport/memory.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,OAAO,eAAe;IACjB,IAAI,GAAqB,EAAE,CAAC;IAC7B,OAAO,CAAqC;IACpD,MAAM,GAAG,KAAK,CAAC;IAEf,SAAS,CAAC,OAA0C;QAClD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,IAAI,CAAC,OAAuB;QAC1B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED,oEAAoE;IACpE,OAAO,CAAC,OAAuB;QAC7B,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC;IAC1B,CAAC;IAED,KAAK;QACH,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IACrB,CAAC;CACF"}

package/dist/transport/stdio.d.ts

@@ -0,0 +1,9 @@
+import type { Readable, Writable } from 'node:stream';
+import type { MessageTransport } from './types.js';
+/**
+ * Stdio transport: reads newline-delimited JSON-RPC messages from a Readable and writes them
+ * to a Writable. Used to bridge the parent process stdio (the MCP client) and a spawned
+ * server child's stdio.
+ */
+export declare function streamTransport(input: Readable, output: Writable): MessageTransport;
+//# sourceMappingURL=stdio.d.ts.map

package/dist/transport/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/transport/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,GAAG,gBAAgB,CA8BnF"}

package/dist/transport/stdio.js

@@ -0,0 +1,36 @@
+import { parseMessage, serializeMessage } from '../jsonrpc.js';
+/**
+ * Stdio transport: reads newline-delimited JSON-RPC messages from a Readable and writes them
+ * to a Writable. Used to bridge the parent process stdio (the MCP client) and a spawned
+ * server child's stdio.
+ */
+export function streamTransport(input, output) {
+    let handler;
+    let buffer = '';
+    const onData = (chunk) => {
+        buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        let newlineIndex = buffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            const message = parseMessage(line);
+            if (message && handler)
+                handler(message);
+            newlineIndex = buffer.indexOf('\n');
+        }
+    };
+    input.setEncoding('utf8');
+    input.on('data', onData);
+    return {
+        onMessage(h) {
+            handler = h;
+        },
+        send(message) {
+            output.write(serializeMessage(message));
+        },
+        close() {
+            input.off('data', onData);
+        },
+    };
+}
+//# sourceMappingURL=stdio.js.map

package/dist/transport/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../src/transport/stdio.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAuB,MAAM,eAAe,CAAC;AAGpF;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,KAAe,EAAE,MAAgB;IAC/D,IAAI,OAAwD,CAAC;IAC7D,IAAI,MAAM,GAAG,EAAE,CAAC;IAEhB,MAAM,MAAM,GAAG,CAAC,KAAsB,EAAQ,EAAE;QAC9C,MAAM,IAAI,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QACrE,IAAI,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACxC,OAAO,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;YAC3C,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC;YACxC,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;YACnC,IAAI,OAAO,IAAI,OAAO;gBAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACzC,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QACtC,CAAC;IACH,CAAC,CAAC;IAEF,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;IAC1B,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEzB,OAAO;QACL,SAAS,CAAC,CAAC;YACT,OAAO,GAAG,CAAC,CAAC;QACd,CAAC;QACD,IAAI,CAAC,OAAO;YACV,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAC,CAAC;QAC1C,CAAC;QACD,KAAK;YACH,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/transport/types.d.ts

@@ -0,0 +1,14 @@
+import type { JsonRpcMessage } from '../jsonrpc.js';
+/**
+ * A bidirectional MCP message transport. The proxy wires two of these together (client-side
+ * and server-side). Concrete transports (stdio streams, in-memory test) implement it.
+ */
+export interface MessageTransport {
+    /** Register the handler for messages arriving from the peer. Called once. */
+    onMessage(handler: (message: JsonRpcMessage) => void): void;
+    /** Send a message to the peer. */
+    send(message: JsonRpcMessage): void;
+    /** Close the transport and release resources. */
+    close(): void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/transport/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6EAA6E;IAC7E,SAAS,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,GAAG,IAAI,CAAC;IAC5D,kCAAkC;IAClC,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAAC;IACpC,iDAAiD;IACjD,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dist/transport/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/transport/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/transport/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@mcpfold/proxy",
+  "version": "1.0.0",
+  "description": "Thin local MCP proxy for tool-level curation: transparent passthrough + tools/list filtering.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mcpfold/core": "1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dj-pearson/MCPFold.git",
+    "directory": "packages/proxy"
+  },
+  "homepage": "https://mcpfold.com",
+  "bugs": {
+    "url": "https://github.com/dj-pearson/MCPFold/issues"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "lint": "eslint . --max-warnings=0",
+    "typecheck": "tsc --noEmit",
+    "bench": "WRITE_BENCH=1 vitest run test/benchmark.test.ts"
+  }
+}