@bigdata-oflow/mcp-server 0.1.0

package/README.md

@@ -0,0 +1,89 @@
+# mcp-server-oflow (Node.js)
+
+oflow MCP server 的 Node.js 实现，支持通过 npx 直接运行。
+
+## 安装 & 运行
+
+通过 npx 直接运行（无需安装）：
+
+```bash
+npx mcp-server-oflow
+```
+
+或全局安装后运行：
+
+```bash
+npm install -g mcp-server-oflow
+mcp-server-oflow
+```
+
+## 配置
+
+在 `mcp_servers.json` 中添加：
+
+### stdio 模式
+
+```json
+{
+  "mcpServers": {
+    "mcp-server-oflow": {
+      "command": "npx",
+      "args": ["-y", "mcp-server-oflow"],
+      "env": {
+        "APP_ID": "YOUR APP ID",
+        "APP_SECRET": "YOUR APP SECRET"
+      }
+    }
+  }
+}
+```
+
+### SSE 模式
+
+服务端启动：
+
+```bash
+npx mcp-server-oflow --transport=sse --port=8001
+```
+
+客户端配置：
+
+```json
+{
+  "mcp-server-oflow": {
+    "url": "http://localhost:8001/sse",
+    "headers": {},
+    "timeout": 60,
+    "sse_read_timeout": 60
+  }
+}
+```
+
+## 环境变量
+
+| 变量 | 说明 | 必填 |
+|------|------|------|
+| `APP_ID` | oflow 接口验签 App ID | stdio 模式必填 |
+| `APP_SECRET` | oflow 接口验签 App Secret | stdio 模式必填 |
+| `AREA` | 区域选择：`CN`(默认) / `SGP` / `INDIA` | 否 |
+| `USER_ID` | 用户标识 | 否 |
+
+APP_ID 和 APP_SECRET 是 oflow 接口验签秘钥，联系 oflow 管理员（谭集友-W9009858）申请开通。
+
+> SSE 模式下，客户端调用 call_tool 时也可以把 `app_id` 和 `app_secret` 放在 POST 请求 `arguments` 参数中传入。
+
+## CLI 参数
+
+```
+--transport    传输模式: stdio (默认) 或 sse
+--host         SSE 模式监听地址 (默认: 0.0.0.0)
+--port         SSE 模式监听端口 (默认: 8000)
+```
+
+## 开发
+
+```bash
+cd nodejs
+npm install
+npm start
+```

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@bigdata-oflow/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for oflow",
+  "type": "module",
+  "bin": {
+    "mcp-server-oflow": "src/index.js"
+  },
+  "files": [
+    "src/"
+  ],
+  "scripts": {
+    "start": "node src/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "express": "^4.21.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}

package/src/index.js

@@ -0,0 +1,198 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { createHash } from "node:crypto";
+import { parseArgs } from "node:util";
+import express from "express";
+
+const URLS = {
+  CN: "http://oflow.oppoer.me",
+  SGP: "http://oflowf.oppoer.me",
+  INDIA: "http://oflow.inali.oppoer.me",
+};
+
+function data2str(data) {
+  const keys = Object.keys(data).sort();
+  return keys
+    .map((key) => {
+      let value = data[key];
+      if (value === true) value = "true";
+      if (value === false) value = "false";
+      if (value == null) value = "null";
+      return `${key}=${value}`;
+    })
+    .join("&");
+}
+
+function generateSignature(args, appKey, url) {
+  delete args.sign;
+  const argsStr = data2str(args);
+  const strToMd5 = `${argsStr}:${url}:${appKey}`;
+  return createHash("md5").update(strToMd5, "utf-8").digest("hex").toLowerCase();
+}
+
+async function fetchToolsList(baseUrl) {
+  const path = "/mcp/list_tools";
+  const response = await fetch(baseUrl + path);
+  return response.json();
+}
+
+function createServer() {
+  let toolsMeta = {};
+
+  const server = new Server(
+    { name: "mcp-server-oflow", version: "0.1.1" },
+    { capabilities: { tools: {} } }
+  );
+
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const area = process.env.AREA || "CN";
+    const url = URLS[area] || URLS.CN;
+    try {
+      const data = await fetchToolsList(url);
+      toolsMeta = data.tools_meta || {};
+      const tools = (data.tools || []).map((item) => ({
+        name: item.name,
+        description: item.description,
+        inputSchema: item.parameters || {},
+      }));
+      return { tools };
+    } catch (e) {
+      console.error(`ERROR: get oflow mcp tools failed: ${e.message}`);
+      return { tools: [] };
+    }
+  });
+
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: rawArgs } = request.params;
+    const args = { ...(rawArgs || {}) };
+    const meta = toolsMeta[name] || {};
+    const method = meta.method;
+    const path = meta.path;
+    const area = args.area || "CN";
+    delete args.area;
+
+    const appId = process.env.APP_ID || args.app_id;
+    const appSecret = process.env.APP_SECRET || args.app_secret;
+    delete args.app_id;
+    delete args.app_secret;
+
+    if (!appId || !appSecret) {
+      return {
+        content: [{ type: "text", text: "not found ENV: APP_ID & APP_SECRET" }],
+      };
+    }
+
+    if (!method || !path) {
+      return {
+        content: [{ type: "text", text: "not found tools result" }],
+      };
+    }
+
+    try {
+      const url = URLS[area] || URLS.CN;
+      args.app_id = appId;
+      args.request_id = Math.floor(Date.now() / 1000);
+      if (process.env.USER_ID) {
+        args.user = process.env.USER_ID;
+      }
+      args.sign = generateSignature(args, appSecret, path);
+
+      let response;
+      const upperMethod = method.toUpperCase();
+
+      if (upperMethod === "PATCH" || upperMethod === "POST") {
+        response = await fetch(url + path, {
+          method: upperMethod,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(args),
+          signal: AbortSignal.timeout(60000),
+        });
+      } else {
+        const params = new URLSearchParams();
+        for (const [k, v] of Object.entries(args)) {
+          params.append(k, String(v));
+        }
+        response = await fetch(`${url}${path}?${params}`, {
+          signal: AbortSignal.timeout(60000),
+        });
+      }
+
+      const rawText = await response.text();
+      let text;
+      try {
+        text = JSON.stringify(JSON.parse(rawText), null, 2);
+      } catch {
+        text = rawText;
+      }
+      return { content: [{ type: "text", text }] };
+    } catch (e) {
+      return {
+        content: [{ type: "text", text: `call tool failed, reason: ${e.message}` }],
+      };
+    }
+  });
+
+  return server;
+}
+
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      transport: { type: "string", default: "stdio", short: "t" },
+      host: { type: "string", default: "0.0.0.0" },
+      port: { type: "string", default: "8000" },
+    },
+  });
+
+  const transport = values.transport;
+  const port = parseInt(values.port, 10);
+
+  if (transport === "sse") {
+    const app = express();
+    app.use(express.json());
+
+    const sessions = new Map();
+
+    app.get("/sse", async (req, res) => {
+      const sseTransport = new SSEServerTransport("/messages", res);
+      const server = createServer();
+      sessions.set(sseTransport.sessionId, { server, transport: sseTransport });
+
+      res.on("close", () => {
+        sessions.delete(sseTransport.sessionId);
+      });
+
+      await server.connect(sseTransport);
+    });
+
+    app.post("/messages", async (req, res) => {
+      const sessionId = req.query.sessionId;
+      const session = sessions.get(sessionId);
+      if (session) {
+        await session.transport.handlePostMessage(req, res);
+      } else {
+        res.status(404).json({ error: "Session not found" });
+      }
+    });
+
+    app.listen(port, values.host, () => {
+      console.log(
+        `MCP server started with SSE transport on http://${values.host}:${port}/sse`
+      );
+    });
+  } else {
+    const server = createServer();
+    const stdioTransport = new StdioServerTransport();
+    await server.connect(stdioTransport);
+    console.error("MCP server started with stdio transport");
+  }
+}
+
+main().catch(console.error);