@silver886/mcp-proxy 0.1.3 → 0.2.0

package/mcp/dist/proxy.js

@@ -1,374 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const protocol_js_1 = require("./shared/protocol.js");
-const POLL_INTERVAL = 2000; // ms
-const TOOL_SEPARATOR = "__";
-const subtle = node_crypto_1.webcrypto.subtle;
-// --- Crypto helpers (AES-256-GCM + SHA-256 + HMAC) ---
-async function importAesKey(keyB64) {
-    const raw = Buffer.from(keyB64, "base64url");
-    return subtle.importKey("raw", raw, "AES-GCM", false, ["encrypt", "decrypt"]);
-}
-async function importHmacKey(keyB64) {
-    const raw = Buffer.from(keyB64, "base64url");
-    return subtle.importKey("raw", raw, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-}
-async function deriveCodeId(code) {
-    const hash = await subtle.digest("SHA-256", new TextEncoder().encode(code));
-    return Buffer.from(hash).toString("base64url");
-}
-async function deriveAuthHash(keyB64, code) {
-    const hmacKey = await importHmacKey(keyB64);
-    const sig = await subtle.sign("HMAC", hmacKey, new TextEncoder().encode(code));
-    return Buffer.from(sig).toString("base64url");
-}
-async function encrypt(key, plaintext) {
-    const iv = (0, node_crypto_1.randomBytes)(12);
-    const encoded = new TextEncoder().encode(plaintext);
-    const ciphertext = new Uint8Array(await subtle.encrypt({ name: "AES-GCM", iv }, key, encoded));
-    const combined = new Uint8Array(iv.length + ciphertext.length);
-    combined.set(iv);
-    combined.set(ciphertext, iv.length);
-    return Buffer.from(combined).toString("base64url");
-}
-async function decrypt(key, data) {
-    const combined = Buffer.from(data, "base64url");
-    const iv = combined.subarray(0, 12);
-    const ciphertext = combined.subarray(12);
-    const plaintext = await subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
-    return new TextDecoder().decode(plaintext);
-}
-// --- RPC client ---
-async function rpc(pagesUrl, codeId, authHash, action, payload) {
-    const resp = await fetch(`${pagesUrl}/api/rpc`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ codeId, authHash, action, payload }),
-    });
-    return (await resp.json());
-}
-// --- Proxy ---
-class ProxyServer {
-    config = null;
-    pagesUrl;
-    code;
-    encKeyB64;
-    aesKey = null;
-    codeId = null;
-    authHash = null;
-    pollTimer = null;
-    servers = new Map();
-    toolRoute = new Map();
-    initialized = false;
-    constructor(pagesUrl) {
-        this.pagesUrl = pagesUrl.replace(/\/+$/, "");
-        this.code = (0, node_crypto_1.randomBytes)(64).toString("base64url");
-        this.encKeyB64 = (0, node_crypto_1.randomBytes)(32).toString("base64url");
-    }
-    get setupUrl() {
-        return `${this.pagesUrl}/setup.html#code=${this.code}&key=${this.encKeyB64}`;
-    }
-    get hostHeaders() {
-        return {
-            "Content-Type": "application/json",
-            Accept: "application/json, text/event-stream",
-            Authorization: `Bearer ${this.config?.authToken ?? ""}`,
-        };
-    }
-    async ensureDerivedKeys() {
-        if (!this.aesKey)
-            this.aesKey = await importAesKey(this.encKeyB64);
-        if (!this.codeId)
-            this.codeId = await deriveCodeId(this.code);
-        if (!this.authHash)
-            this.authHash = await deriveAuthHash(this.encKeyB64, this.code);
-        return { aesKey: this.aesKey, codeId: this.codeId, authHash: this.authHash };
-    }
-    start() {
-        this.startPairing();
-        const stdinBuffer = new protocol_js_1.LineBuffer();
-        process.stdin.setEncoding("utf-8");
-        process.stdin.on("data", (chunk) => {
-            const lines = stdinBuffer.push(chunk);
-            for (const line of lines) {
-                this.handleLine(line).catch((err) => {
-                    process.stderr.write(`Proxy error: ${err.message}\n`);
-                });
-            }
-        });
-        process.stdin.on("end", () => {
-            process.exit(0);
-        });
-    }
-    async handleLine(line) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            return;
-        }
-        const id = parsed.id ?? null;
-        // Handle client notifications (no id)
-        if (id === null)
-            return;
-        switch (parsed.method) {
-            // initialize always succeeds — proxy is a valid server even before pairing
-            case "initialize":
-                this.sendResult(id, {
-                    protocolVersion: protocol_js_1.MCP_PROTOCOL_VERSION,
-                    capabilities: { tools: { listChanged: true }, prompts: {}, logging: {} },
-                    serverInfo: { name: protocol_js_1.PACKAGE_NAME, version: protocol_js_1.PACKAGE_VERSION },
-                });
-                return;
-            // tools/list returns configure tool before pairing, real tools after
-            case "tools/list":
-                if (!this.config) {
-                    this.sendResult(id, { tools: [{
-                                name: "configure",
-                                description: "Set up or reconfigure the MCP proxy connection. Returns the setup URL.",
-                                inputSchema: { type: "object", properties: {} },
-                            }] });
-                    return;
-                }
-                if (!this.initialized)
-                    await this.discoverServers();
-                this.sendResult(id, { tools: this.getFilteredTools() });
-                return;
-            // prompts/list always available
-            case "prompts/list":
-                this.sendResult(id, { prompts: [{
-                            name: "configure",
-                            description: "Set up or reconfigure the MCP proxy connection",
-                        }] });
-                return;
-            case "prompts/get": {
-                const promptName = parsed.params?.name;
-                if (promptName === "configure") {
-                    const text = await this.handleConfigure();
-                    this.sendResult(id, {
-                        messages: [{ role: "user", content: { type: "text", text } }],
-                    });
-                }
-                else {
-                    this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown prompt: ${promptName}`, id);
-                }
-                return;
-            }
-            case "tools/call": {
-                const toolName = parsed.params?.name;
-                if (toolName === "configure") {
-                    const text = await this.handleConfigure();
-                    this.sendResult(id, { content: [{ type: "text", text }] });
-                    return;
-                }
-                if (!this.config) {
-                    this.sendError(protocol_js_1.ErrorCode.PROXY_NOT_CONFIGURED, `Visit ${this.setupUrl}`, id);
-                    return;
-                }
-                await this.handleToolCall(id, parsed.params);
-                return;
-            }
-            default:
-                this.sendError(protocol_js_1.ErrorCode.METHOD_NOT_FOUND, parsed.method, id);
-        }
-    }
-    async handleToolCall(id, params) {
-        const prefixedName = params.name;
-        const serverName = this.toolRoute.get(prefixedName);
-        if (!serverName) {
-            this.sendError(protocol_js_1.ErrorCode.INVALID_PARAMS, `Unknown tool: ${prefixedName}`, id);
-            return;
-        }
-        const originalName = prefixedName.slice(serverName.length + TOOL_SEPARATOR.length);
-        const server = this.servers.get(serverName);
-        const targetUrl = `${this.config.tunnelUrl}/servers/${serverName}`;
-        const headers = { ...this.hostHeaders };
-        if (server.sessionId)
-            headers["Mcp-Session-Id"] = server.sessionId;
-        try {
-            const body = JSON.stringify({
-                jsonrpc: "2.0",
-                id,
-                method: "tools/call",
-                params: { name: originalName, arguments: params.arguments },
-            });
-            const upstream = await fetch(targetUrl, { method: "POST", headers, body });
-            server.sessionId = upstream.headers.get("mcp-session-id") ?? server.sessionId;
-            const responseBody = await upstream.text();
-            if (responseBody)
-                process.stdout.write(responseBody + "\n");
-        }
-        catch (err) {
-            this.sendError(protocol_js_1.ErrorCode.HOST_UNREACHABLE, err.message, id);
-        }
-    }
-    getFilteredTools() {
-        const selectedSet = this.config?.selectedTools?.length
-            ? new Set(this.config.selectedTools)
-            : null;
-        const tools = [];
-        for (const [serverName, state] of this.servers) {
-            for (const tool of state.tools) {
-                const prefixed = `${serverName}${TOOL_SEPARATOR}${tool.name}`;
-                if (selectedSet && !selectedSet.has(prefixed))
-                    continue;
-                tools.push({
-                    ...tool,
-                    name: prefixed,
-                    description: `[${serverName}] ${tool.description ?? ""}`.trim(),
-                });
-            }
-        }
-        return tools;
-    }
-    async discoverServers() {
-        if (!this.config)
-            return;
-        try {
-            const listResp = await fetch(`${this.config.tunnelUrl}/`, { headers: this.hostHeaders });
-            const listData = (await listResp.json());
-            const serverNames = listData.servers ?? [];
-            // Skip servers whose names contain the tool separator to prevent routing confusion
-            const safeNames = serverNames.filter((name) => {
-                if (name.includes(TOOL_SEPARATOR)) {
-                    process.stderr.write(`  [${name}] skipped: name contains '${TOOL_SEPARATOR}'\n`);
-                    return false;
-                }
-                return true;
-            });
-            process.stderr.write(`  Discovered servers: ${safeNames.join(", ")}\n`);
-            for (const name of safeNames) {
-                await this.initServer(name);
-            }
-            this.toolRoute.clear();
-            for (const [serverName, state] of this.servers) {
-                for (const tool of state.tools) {
-                    this.toolRoute.set(`${serverName}${TOOL_SEPARATOR}${tool.name}`, serverName);
-                }
-            }
-            this.initialized = true;
-            process.stderr.write(`  Total tools: ${this.toolRoute.size}\n\n`);
-        }
-        catch (err) {
-            process.stderr.write(`  Discovery failed: ${err.message}\n`);
-        }
-    }
-    async initServer(name) {
-        const targetUrl = `${this.config.tunnelUrl}/servers/${name}`;
-        const headers = { ...this.hostHeaders };
-        try {
-            const initResp = await fetch(targetUrl, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: `init-${name}`,
-                    method: "initialize",
-                    params: {
-                        protocolVersion: protocol_js_1.MCP_PROTOCOL_VERSION,
-                        capabilities: {},
-                        clientInfo: { name: protocol_js_1.PACKAGE_NAME, version: protocol_js_1.PACKAGE_VERSION },
-                    },
-                }),
-            });
-            const sessionId = initResp.headers.get("mcp-session-id") ?? undefined;
-            if (sessionId)
-                headers["Mcp-Session-Id"] = sessionId;
-            await fetch(targetUrl, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }),
-            });
-            const toolsResp = await fetch(targetUrl, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ jsonrpc: "2.0", id: `tools-${name}`, method: "tools/list", params: {} }),
-            });
-            const toolsData = (await toolsResp.json());
-            const tools = toolsData.result?.tools ?? [];
-            this.servers.set(name, { sessionId, tools });
-            process.stderr.write(`  [${name}] ${tools.length} tools\n`);
-        }
-        catch (err) {
-            process.stderr.write(`  [${name}] init failed: ${err.message}\n`);
-        }
-    }
-    sendResult(id, result) {
-        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, result }) + "\n");
-    }
-    sendError(code, detail, id) {
-        process.stdout.write((0, protocol_js_1.jsonRpcError)(code, detail, id) + "\n");
-    }
-    sendNotification(method) {
-        process.stdout.write(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
-    }
-    async handleConfigure() {
-        if (this.config) {
-            await this.startPairing();
-            this.sendNotification("notifications/tools/list_changed");
-        }
-        return `Open this URL in your browser to set up the MCP Proxy:\n\n${this.setupUrl}\n\nThe proxy will connect automatically once setup is complete.`;
-    }
-    async startPairing() {
-        if (this.pollTimer)
-            clearInterval(this.pollTimer);
-        const previousConfig = this.config;
-        this.code = (0, node_crypto_1.randomBytes)(64).toString("base64url");
-        this.encKeyB64 = (0, node_crypto_1.randomBytes)(32).toString("base64url");
-        this.aesKey = null;
-        this.codeId = null;
-        this.authHash = null;
-        this.config = null;
-        this.initialized = false;
-        this.servers.clear();
-        this.toolRoute.clear();
-        // Seed with encrypted previous config (unsealed) — skip on first pairing
-        if (previousConfig) {
-            try {
-                const { aesKey, codeId, authHash } = await this.ensureDerivedKeys();
-                const payload = await encrypt(aesKey, JSON.stringify({ ...previousConfig, sealed: false }));
-                await rpc(this.pagesUrl, codeId, authHash, "write", payload);
-            }
-            catch {
-                // Non-critical
-            }
-        }
-        process.stderr.write(`\n  Configure at: ${this.setupUrl}\n\n`);
-        process.stderr.write(`  Waiting for configuration...\n`);
-        this.pollTimer = setInterval(() => this.pollConfig(), POLL_INTERVAL);
-    }
-    async pollConfig() {
-        if (this.config)
-            return; // Already paired — guard against overlapping async polls
-        try {
-            const { aesKey, codeId, authHash } = await this.ensureDerivedKeys();
-            const result = await rpc(this.pagesUrl, codeId, authHash, "read");
-            if (result.payload) {
-                const plaintext = await decrypt(aesKey, result.payload);
-                const data = JSON.parse(plaintext);
-                if (data.tunnelUrl && data.authToken && data.serverName && data.sealed) {
-                    data.tunnelUrl = data.tunnelUrl.replace(/\/+$/, "");
-                    this.config = data;
-                    if (this.pollTimer)
-                        clearInterval(this.pollTimer);
-                    this.pollTimer = null;
-                    process.stderr.write(`  Paired! tunnel=${data.tunnelUrl}\n`);
-                    await this.discoverServers();
-                    this.sendNotification("notifications/tools/list_changed");
-                }
-            }
-        }
-        catch {
-            // Silently retry
-        }
-    }
-}
-function main() {
-    const pagesUrl = (0, protocol_js_1.getArg)("--pages-url") ?? process.env.MCP_PROXY_PAGES_URL ?? protocol_js_1.DEFAULT_PAGES_URL;
-    const proxy = new ProxyServer(pagesUrl);
-    proxy.start();
-}
-main();

package/mcp/dist/shared/generated.d.ts

@@ -1,2 +0,0 @@
-export declare const PACKAGE_NAME = "@silver886/mcp-proxy";
-export declare const PACKAGE_VERSION = "0.1.3";

package/mcp/dist/shared/generated.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PACKAGE_VERSION = exports.PACKAGE_NAME = void 0;
-exports.PACKAGE_NAME = "@silver886/mcp-proxy";
-exports.PACKAGE_VERSION = "0.1.3";

package/mcp/dist/shared/protocol.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LineBuffer = exports.ErrorMessage = exports.ErrorCode = exports.DEFAULT_PAGES_URL = exports.DEFAULT_PORT = exports.DEFAULT_HOST = exports.MCP_PROTOCOL_VERSION = exports.PACKAGE_VERSION = exports.PACKAGE_NAME = void 0;
-exports.jsonRpcError = jsonRpcError;
-exports.readBody = readBody;
-exports.getArg = getArg;
-exports.createServer = createServer;
-const node_http_1 = require("node:http");
-var generated_js_1 = require("./generated.js");
-Object.defineProperty(exports, "PACKAGE_NAME", { enumerable: true, get: function () { return generated_js_1.PACKAGE_NAME; } });
-Object.defineProperty(exports, "PACKAGE_VERSION", { enumerable: true, get: function () { return generated_js_1.PACKAGE_VERSION; } });
-exports.MCP_PROTOCOL_VERSION = "2024-11-05";
-exports.DEFAULT_HOST = "127.0.0.1";
-exports.DEFAULT_PORT = 6270;
-exports.DEFAULT_PAGES_URL = "https://mcp-proxy.pages.dev";
-// JSON-RPC error codes: -32600..-32603 = spec-defined, -32000..-32099 = server-defined
-exports.ErrorCode = {
-    METHOD_NOT_FOUND: -32601, // JSON-RPC spec: method not found
-    INVALID_PARAMS: -32602, // JSON-RPC spec: invalid params
-    INTERNAL: -32603, // JSON-RPC spec: internal error
-    PROXY_NOT_CONFIGURED: -32001, // Proxy has not been paired yet
-    HOST_UNREACHABLE: -32002, // Cannot reach the host agent via tunnel
-    PROCESS_EXITED: -32003, // MCP server child process exited unexpectedly
-    PROCESS_NOT_RUNNING: -32004, // MCP server child process is not running
-    REQUEST_TIMEOUT: -32005, // MCP server did not respond in time
-};
-exports.ErrorMessage = {
-    [exports.ErrorCode.METHOD_NOT_FOUND]: "Method not found",
-    [exports.ErrorCode.INVALID_PARAMS]: "Invalid params",
-    [exports.ErrorCode.INTERNAL]: "Internal error",
-    [exports.ErrorCode.PROXY_NOT_CONFIGURED]: "Proxy not configured",
-    [exports.ErrorCode.HOST_UNREACHABLE]: "Host agent unreachable",
-    [exports.ErrorCode.PROCESS_EXITED]: "Server process exited",
-    [exports.ErrorCode.PROCESS_NOT_RUNNING]: "Server process not running",
-    [exports.ErrorCode.REQUEST_TIMEOUT]: "Request timed out",
-};
-// JSON-RPC error response helper
-function jsonRpcError(code, detail, id = null) {
-    const base = exports.ErrorMessage[code] ?? "Unknown error";
-    const message = detail ? `${base}: ${detail}` : base;
-    return JSON.stringify({ jsonrpc: "2.0", error: { code, message }, id });
-}
-// Read full request body as string
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on("data", (c) => chunks.push(c));
-        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-        req.on("error", reject);
-    });
-}
-// Parse CLI argument by name: --flag value
-function getArg(name) {
-    const idx = process.argv.indexOf(name);
-    return idx !== -1 && idx + 1 < process.argv.length ? process.argv[idx + 1] : undefined;
-}
-// Create HTTP server with async handler and error catching
-function createServer(handler) {
-    return (0, node_http_1.createServer)((req, res) => {
-        handler(req, res).catch((err) => {
-            console.error(`Request handler error: ${err.message}`);
-            if (!res.headersSent) {
-                res.writeHead(500, { "Content-Type": "application/json" });
-                res.end(jsonRpcError(exports.ErrorCode.INTERNAL));
-            }
-        });
-    });
-}
-// Line-buffered reader: accumulates chunks and yields complete lines
-class LineBuffer {
-    buffer = "";
-    push(chunk) {
-        this.buffer += chunk;
-        const parts = this.buffer.split("\n");
-        this.buffer = parts.pop(); // Keep incomplete trailing segment
-        return parts.filter((line) => line.trim().length > 0);
-    }
-}
-exports.LineBuffer = LineBuffer;