@szc-ft/mcp-szcd-client 0.11.0

package/mcp-proxy.js

@@ -0,0 +1,543 @@
+#!/usr/bin/env node
+/**
+ * MCP Proxy - stdio-to-StreamableHTTP/SSE 桥接代理
+ *
+ * 用于向后兼容旧的客户端配置。
+ * 新客户端可以直接连接 Streamable HTTP 端点（POST /mcp）。
+ *
+ * 工作原理：
+ * 1. IDE 通过 stdio 发送 JSON-RPC 消息给本代理
+ * 2. 本代理通过 Streamable HTTP（POST /mcp）转发到远程 MCP 服务器
+ * 3. 服务器的响应通过 HTTP 响应返回，本代理再通过 stdout 转发给 IDE
+ *
+ * 传输模式自动检测：
+ * - 优先使用 Streamable HTTP（POST /mcp）
+ * - 回退到 SSE（GET /sse + POST /message）
+ * - 最终回退到旧版 REST API（/tools/list, /tools/call）
+ */
+
+import http from "node:http";
+import https from "node:https";
+import readline from "node:readline";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// ==================== 配置加载 ====================
+
+function getConfigFilePath() {
+    const platform = os.platform();
+    if (platform === "win32") {
+        return path.join(process.env.USERPROFILE || process.env.HOME, ".szcd-mcp-config.json");
+    } else {
+        return path.join(process.env.HOME || os.homedir(), ".szcd-mcp-config.json");
+    }
+}
+
+function loadConfigFromFile() {
+    const configPath = getConfigFilePath();
+    try {
+        if (fs.existsSync(configPath)) {
+            const content = fs.readFileSync(configPath, "utf8");
+            return JSON.parse(content);
+        }
+    } catch (error) {
+        // 配置文件读取失败，使用默认值
+    }
+    return {};
+}
+
+const fileConfig = loadConfigFromFile();
+
+// 配置优先级：环境变量 > 配置文件 > 默认值
+const SERVER_URL = process.env.MCP_SERVER_URL || fileConfig.MCP_SERVER_URL || "http://localhost:3456";
+const SERVER_TIMEOUT = parseInt(process.env.MCP_TIMEOUT || fileConfig.MCP_TIMEOUT || "120000", 10);
+const SERVER_API_KEY = process.env.MCP_API_KEY || fileConfig.MCP_API_KEY || "";
+
+// ==================== 日志 ====================
+
+function log(msg) {
+    console.error(`[${new Date().toISOString()}] ${msg}`);
+}
+
+log(`Server URL: ${SERVER_URL}`);
+log(`Timeout: ${SERVER_TIMEOUT}`);
+log(`API Key: ${SERVER_API_KEY ? "set" : "not set"}`);
+
+// ==================== 测试模式 ====================
+
+if (process.argv.includes("--test")) {
+    console.log("Testing MCP proxy connection...");
+    console.log(`Server URL: ${SERVER_URL}`);
+
+    const url = new URL("/health", SERVER_URL);
+    const requestImpl = url.protocol === "https:" ? https : http;
+
+    const req = requestImpl.get(url, { timeout: SERVER_TIMEOUT }, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed.status === "ok") {
+                    console.log("Connection test successful!", parsed);
+                    process.exit(0);
+                } else {
+                    console.error("Connection test failed: unexpected response", parsed);
+                    process.exit(1);
+                }
+            } catch {
+                console.error("Connection test failed: invalid JSON response");
+                process.exit(1);
+            }
+        });
+    });
+
+    req.on("error", (e) => {
+        console.error("Connection test failed:", e.message);
+        process.exit(1);
+    });
+
+    req.on("timeout", () => {
+        req.destroy();
+        console.error("Connection test failed: timeout");
+        process.exit(1);
+    });
+
+    process.exit(0);
+}
+
+// ==================== 传输模式 ====================
+
+const TRANSPORT_MODE = {
+    STREAMABLE_HTTP: "streamable_http",
+    SSE: "sse",
+    LEGACY_REST: "legacy_rest",
+};
+
+let currentMode = null;
+let httpSessionId = null;
+
+// ==================== Streamable HTTP 转发 ====================
+
+function forwardToStreamableHttp(msg) {
+    return new Promise((resolve) => {
+        const url = new URL("/mcp", SERVER_URL);
+        const isHttps = url.protocol === "https:";
+        const requestImpl = isHttps ? https : http;
+
+        const headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "User-Agent": "Claude-Code-MCP-Proxy/0.4.3",
+        };
+        if (SERVER_API_KEY) {
+            headers["X-API-Key"] = SERVER_API_KEY;
+            headers["Authorization"] = `Bearer ${SERVER_API_KEY}`;
+        }
+        if (httpSessionId) {
+            headers["Mcp-Session-Id"] = httpSessionId;
+        }
+
+        const postData = JSON.stringify(msg);
+
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname,
+            method: "POST",
+            headers,
+            timeout: SERVER_TIMEOUT,
+            rejectUnauthorized: false,
+        };
+
+        const req = requestImpl.request(options, (res) => {
+            log(`HTTP Response Status: ${res.statusCode}, Headers: ${JSON.stringify(res.headers)}`);
+
+            // 保存 session id
+            const sid = res.headers["mcp-session-id"];
+            if (sid) {
+                httpSessionId = sid;
+                log(`Got session ID: ${sid}`);
+            }
+
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                log(`HTTP Response Body: ${data.substring(0, 500)}${data.length > 500 ? '...' : ''}`);
+
+                const contentType = res.headers["content-type"] || "";
+
+                if (res.statusCode === 406) {
+                    // 特殊处理 406 错误 - 客户端 Accept 头部不匹配
+                    resolve({
+                        jsonrpc: "2.0",
+                        id: msg.id ?? null,
+                        error: {
+                            code: -32000,
+                            message: `Not Acceptable: Server requires Accept header with both 'application/json' and 'text/event-stream'. Response: ${data}`
+                        },
+                    });
+                } else if (contentType.includes("text/event-stream")) {
+                    // SSE 响应：解析 SSE 事件中的 JSON-RPC 消息
+                    const lines = data.split("\n");
+                    for (const line of lines) {
+                        if (line.startsWith("data:")) {
+                            const jsonStr = line.slice(5).trim();
+                            try {
+                                const parsed = JSON.parse(jsonStr);
+                                resolve(parsed);
+                                return;
+                            } catch {
+                                // 继续尝试下一行
+                            }
+                        }
+                    }
+                    // 没有找到有效数据
+                    resolve({
+                        jsonrpc: "2.0",
+                        id: msg.id ?? null,
+                        error: { code: -32000, message: "No valid JSON-RPC response in SSE stream" },
+                    });
+                } else {
+                    // JSON 响应
+                    try {
+                        const parsed = JSON.parse(data);
+                        resolve(parsed);
+                    } catch {
+                        resolve({
+                            jsonrpc: "2.0",
+                            id: msg.id ?? null,
+                            error: {
+                                code: -32000,
+                                message: `Server returned invalid JSON. Status: ${res.statusCode}. Raw body: ${data.slice(0, 200)}`,
+                            },
+                        });
+                    }
+                }
+            });
+        });
+
+        req.on("error", (e) => {
+            log(`HTTP Request Error: ${e.message}`);
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                error: { code: -32000, message: `HTTP request failed: ${e.message}` },
+            });
+        });
+
+        req.on("timeout", () => {
+            req.destroy();
+            log('HTTP Request Timeout');
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                error: { code: -32000, message: "Request timeout" },
+            });
+        });
+
+        log(`Sending HTTP Request: ${JSON.stringify({method: options.method, url: url.toString(), headers: headers})}`);
+        req.write(postData);
+        req.end();
+    });
+}
+
+// ==================== SSE 转发 ====================
+
+let sseSessionId = null;
+let sseMessageEndpoint = null;
+
+function connectSSE() {
+    return new Promise((resolve, reject) => {
+        const url = new URL("/sse", SERVER_URL);
+        const requestImpl = url.protocol === "https:" ? https : http;
+
+        const headers = {
+            "Accept": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "User-Agent": "Claude-Code-MCP-Proxy/0.4.3",
+        };
+        if (SERVER_API_KEY) {
+            headers["X-API-Key"] = SERVER_API_KEY;
+            headers["Authorization"] = `Bearer ${SERVER_API_KEY}`;
+        }
+
+        log(`Connecting to SSE endpoint: ${url.toString()}, headers: ${JSON.stringify(headers)}`);
+
+        const req = requestImpl.get(url, { headers, timeout: SERVER_TIMEOUT }, (res) => {
+            log(`SSE Connection Response Status: ${res.statusCode}, Headers: ${JSON.stringify(res.headers)}`);
+
+            let buffer = "";
+
+            res.on("data", (chunk) => {
+                const chunkStr = chunk.toString();
+                log(`SSE Data Chunk: ${chunkStr.substring(0, 200)}...`);
+
+                buffer += chunkStr;
+
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+
+                for (const line of lines) {
+                    if (line.startsWith("event: endpoint")) {
+                        // 下一个 data 行包含 endpoint URL
+                    } else if (line.startsWith("data:") && !sseMessageEndpoint) {
+                        const data = line.slice(5).trim();
+                        sseMessageEndpoint = data;
+                        sseSessionId = new URL(data, SERVER_URL).searchParams.get("sessionId");
+                        log(`SSE endpoint: ${sseMessageEndpoint}, sessionId: ${sseSessionId}`);
+                        resolve();
+                    }
+                }
+            });
+
+            res.on("end", () => {
+                log("SSE connection closed");
+            });
+        });
+
+        req.on("error", (e) => {
+            log(`SSE connection error: ${e.message}`);
+            reject(e);
+        });
+
+        req.on("timeout", () => {
+            req.destroy();
+            log("SSE connection timeout");
+            reject(new Error("SSE connection timeout"));
+        });
+    });
+}
+
+function forwardToSSEMessageEndpoint(msg) {
+    return new Promise((resolve) => {
+        if (!sseMessageEndpoint) {
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                error: { code: -32000, message: "SSE not connected" },
+            });
+            return;
+        }
+
+        const url = new URL(sseMessageEndpoint, SERVER_URL);
+        const isHttps = url.protocol === "https:";
+        const requestImpl = isHttps ? https : http;
+
+        const headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/event-stream",
+            "User-Agent": "Claude-Code-MCP-Proxy/0.4.3",
+        };
+        if (SERVER_API_KEY) {
+            headers["X-API-Key"] = SERVER_API_KEY;
+            headers["Authorization"] = `Bearer ${SERVER_API_KEY}`;
+        }
+
+        const postData = JSON.stringify(msg);
+
+        const options = {
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            method: "POST",
+            headers,
+            timeout: SERVER_TIMEOUT,
+            rejectUnauthorized: false,
+        };
+
+        const req = requestImpl.request(options, (res) => {
+            log(`SSE Message Response Status: ${res.statusCode}, Headers: ${JSON.stringify(res.headers)}`);
+
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                log(`SSE Message Response Body: ${data.substring(0, 500)}${data.length > 500 ? '...' : ''}`);
+
+                try {
+                    resolve(JSON.parse(data));
+                } catch {
+                    resolve({
+                        jsonrpc: "2.0",
+                        id: msg.id ?? null,
+                        error: { code: -32000, message: `Invalid JSON from SSE message endpoint: ${data.substring(0, 200)}` },
+                    });
+                }
+            });
+        });
+
+        req.on("error", (e) => {
+            log(`SSE Message Request Error: ${e.message}`);
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                error: { code: -32000, message: `SSE message request failed: ${e.message}` },
+            });
+        });
+
+        req.on("timeout", () => {
+            req.destroy();
+            log(`SSE Message Request Timeout`);
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                error: { code: -32000, message: "SSE message request timeout" },
+            });
+        });
+
+        log(`Sending SSE Message Request: ${JSON.stringify({method: options.method, url: url.toString(), headers: headers})}`);
+        req.write(postData);
+        req.end();
+    });
+}
+
+// ==================== 旧版 REST API 转发 ====================
+
+function forwardToRestApi(msg) {
+    return new Promise((resolve) => {
+        if (msg.method === "initialize") {
+            resolve({
+                jsonrpc: "2.0",
+                id: msg.id ?? null,
+                result: {
+                    protocolVersion: "2024-11-05",
+                    serverInfo: { name: "mcp-szcd-component-helper-proxy", version: "0.4.2" },
+                    capabilities: { tools: {} },
+                },
+            });
+            return;
+        }
+        if (msg.method === "ping") {
+            resolve({ jsonrpc: "2.0", id: msg.id ?? null, result: {} });
+            return;
+        }
+
+        resolve({
+            jsonrpc: "2.0",
+            id: msg.id ?? null,
+            error: { code: -32601, message: "Method not found (legacy REST API)" },
+        });
+    });
+}
+
+// ==================== 自动检测传输模式 ====================
+
+async function detectTransportMode() {
+    // 1. 先尝试 Streamable HTTP
+    try {
+        const result = await forwardToStreamableHttp({
+            jsonrpc: "2.0",
+            id: "detect",
+            method: "initialize",
+            params: {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: "mcp-proxy-detect", version: "1.0.0" },
+            },
+        });
+        if (result.result || (result.id === "detect" && !result.error?.message?.includes("Not Acceptable"))) {
+            currentMode = TRANSPORT_MODE.STREAMABLE_HTTP;
+            log(`Transport mode: Streamable HTTP (POST /mcp)`);
+            return;
+        }
+    } catch (e) {
+        log(`Streamable HTTP detection failed: ${e.message}`);
+    }
+
+    // 2. 尝试 SSE
+    try {
+        await connectSSE();
+        if (sseMessageEndpoint) {
+            currentMode = TRANSPORT_MODE.SSE;
+            log(`Transport mode: SSE (GET /sse + POST /message)`);
+            return;
+        }
+    } catch (e) {
+        log(`SSE detection failed: ${e.message}`);
+    }
+
+    // 3. 回退到旧版 REST API
+    currentMode = TRANSPORT_MODE.LEGACY_REST;
+    log(`Transport mode: Legacy REST API`);
+}
+
+// ==================== 主逻辑 ====================
+
+async function main() {
+    await detectTransportMode();
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+
+    rl.on("line", async (line) => {
+        if (!line.trim()) return;
+
+        log(`Received stdin: ${line}`);
+
+        let msgId = null;
+        try {
+            const msg = JSON.parse(line);
+            msgId = msg.id ?? null;
+
+            let response;
+
+            switch (currentMode) {
+                case TRANSPORT_MODE.STREAMABLE_HTTP:
+                    response = await forwardToStreamableHttp(msg);
+                    break;
+                case TRANSPORT_MODE.SSE:
+                    if (msg.method === "initialize") {
+                        // SSE 模式下 initialize 已经在检测时完成
+                        response = {
+                            jsonrpc: "2.0",
+                            id: msgId,
+                            result: {
+                                protocolVersion: "2024-11-05",
+                                serverInfo: { name: "mcp-szcd-component-helper", version: "0.4.2" },
+                                capabilities: { tools: {} },
+                            },
+                        };
+                    } else {
+                        response = await forwardToSSEMessageEndpoint(msg);
+                    }
+                    break;
+                default:
+                    response = await forwardToRestApi(msg);
+                    break;
+            }
+
+            // 构造纯净的 JSON-RPC 响应
+            const cleanResponse = {
+                jsonrpc: "2.0",
+                id: msgId,
+            };
+
+            if (response.error) {
+                cleanResponse.error = response.error;
+            } else {
+                cleanResponse.result = response.result !== undefined ? response.result : null;
+            }
+
+            const output = JSON.stringify(cleanResponse);
+            log(`Sending stdout: ${output}`);
+            process.stdout.write(output + "\n");
+        } catch (e) {
+            log(`Error: ${e.message}`);
+            process.stdout.write(
+                JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: msgId,
+                    error: { code: -32603, message: `Internal proxy error: ${e.message}` },
+                }) + "\n"
+            );
+        }
+    });
+}
+
+main().catch((e) => {
+    log(`Fatal error: ${e.message}`);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "@szc-ft/mcp-szcd-client",
+    "version": "0.11.0",
+    "description": "MCP client for szcd component library - connects to remote MCP server via SSE or stdio proxy",
+    "keywords": [
+        "mcp",
+        "szcd",
+        "component",
+        "ai",
+        "agent",
+        "claude",
+        "skill",
+        "proxy",
+        "sse",
+        "client"
+    ],
+    "author": "szc-ft",
+    "license": "MIT",
+    "type": "module",
+    "main": "mcp-proxy.js",
+    "bin": {
+        "szcd-mcp-proxy": "mcp-proxy.js",
+        "szcd-mcp-setup": "scripts/postinstall.js",
+        "szcd-mcp-update-url": "scripts/update-mcp-url.js"
+    },
+    "files": [
+        "mcp-proxy.js",
+        "scripts/postinstall.js",
+        "scripts/update-mcp-url.js",
+        "scripts/lib/",
+        "standard-skill/",
+        "skill/",
+        "agents/",
+        "commands/",
+        "README.md"
+    ],
+    "engines": {
+        "node": ">=18"
+    },
+    "scripts": {
+        "postinstall": "node scripts/postinstall.js --quick",
+        "setup": "node scripts/postinstall.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.29.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/szc-ft/szcd.git",
+        "directory": "mcp/szcd-mcp-client"
+    },
+    "bugs": {
+        "url": "https://github.com/szc-ft/szcd/issues"
+    },
+    "homepage": "https://github.com/szc-ft/szcd#readme"
+}