@xyd-js/mcp-server 0.0.0-build-9f87f13-20250930210637

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@xyd-js/mcp-server",
+  "version": "0.0.0-build-9f87f13-20250930210637",
+  "type": "module",
+  "description": "MCP server for xyd",
+  "main": "dist/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "xyd-mcp-server": "./bin/xyd-mcp-server.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.18.1",
+    "express": "^5.1.0",
+    "@xyd-js/mcp": "0.0.0-build-9f87f13-20250930210637"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.9.0",
+    "openapi-typescript": "^7.4.2",
+    "typescript": "^5.6.2",
+    "@types/bun": "latest"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "dev": "bun --watch src/index.ts",
+    "start": "bun dist/index.js",
+    "demo:simple": "bun --watch demo/simple/server.ts",
+    "mcp:inspector": "npx @modelcontextprotocol/inspector http://localhost:3000/mcp"
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+import express from "express";
+
+import { MCPServer } from "./mcp";
+
+const mcp = new MCPServer();
+const app = express();
+
+app.use(express.json());
+
+app.post("/mcp", mcp.handleConnectionRequest);
+app.get("/mcp", mcp.handleSessionRequest);
+app.delete("/mcp", mcp.handleSessionRequest);
+
+const port = process.env.PORT || 3000;
+console.log("Running MCP server on port", port);
+
+app.listen(port);
+

package/src/mcp.ts

@@ -0,0 +1,220 @@
+import { randomUUID } from "node:crypto";
+
+import express from "express";
+
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+import { mcpUniformResources, mcpUniformTools } from "@xyd-js/mcp";
+
+// Extend Express Request type to include pendingToken
+declare global {
+  namespace Express {
+    interface Request {
+      pendingToken?: string;
+    }
+  }
+}
+
+export class MCPServer {
+  private transports: { [sessionId: string]: StreamableHTTPServerTransport } =
+    {};
+
+  // Store tokens by session ID
+  private sessionTokens: { [sessionId: string]: string } = {};
+
+  private uniformSource: string = "";
+
+  constructor() {
+    this.connect = this.connect.bind(this);
+    this.handleConnectionRequest = this.handleConnectionRequest.bind(this);
+    this.handleSessionRequest = this.handleSessionRequest.bind(this);
+
+    if (process.argv[2]) {
+      this.uniformSource = process.argv[2];
+    }
+  }
+
+  public async handleConnectionRequest(
+    req: express.Request,
+    res: express.Response
+  ): Promise<void> {
+    // Check for existing session ID
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+    let transport: StreamableHTTPServerTransport;
+
+    if (sessionId && this.transports[sessionId]) {
+      // Reuse existing transport
+      transport = this.transports[sessionId];
+    } else if (!sessionId && isInitializeRequest(req.body)) {
+      // Extract and store token
+      const authorized = req.headers["authorization"];
+      const bearer = authorized?.split("Bearer");
+      let token = "";
+      if (bearer && bearer.length > 1) {
+        token = bearer[1].trim();
+      }
+
+      transport = await this.connect(token);
+    } else {
+      // Invalid request
+      res.status(400).json({
+        jsonrpc: "2.0",
+        error: {
+          code: -32000,
+          message: "Bad Request: No valid session ID provided",
+        },
+        id: null,
+      });
+      return;
+    }
+
+    // Handle the request
+    await transport.handleRequest(req, res, req.body);
+  }
+
+  public async handleSessionRequest(
+    req: express.Request,
+    res: express.Response
+  ): Promise<void> {
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+    if (!sessionId || !this.transports[sessionId]) {
+      res.status(400).send("Invalid or missing session ID");
+      return;
+    }
+
+    const transport = this.transports[sessionId];
+    await transport.handleRequest(req, res);
+  }
+
+  private async connect(
+    token?: string
+  ): Promise<StreamableHTTPServerTransport> {
+    // New initialization request
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID(),
+      onsessioninitialized: (sessionId) => {
+        // Store the transport by session ID
+        this.transports[sessionId] = transport;
+
+        // Store the token for this session if we have one
+        if (token) {
+          this.sessionTokens[sessionId] = token;
+        }
+      },
+      // DNS rebinding protection is disabled by default for backwards compatibility. If you are running this server
+      // locally, make sure to set:
+      // enableDnsRebindingProtection: true,
+      // allowedHosts: ['127.0.0.1'],
+    });
+
+    // Clean up transport when closed
+    transport.onclose = () => {
+      if (transport.sessionId) {
+        delete this.transports[transport.sessionId];
+        delete this.sessionTokens[transport.sessionId];
+        console.log("Cleaned up session:", transport.sessionId);
+      }
+    };
+
+    const server = new McpServer({
+      name: "xyd-mcp-server",
+      version: "1.0.0",
+    });
+
+    if (this.uniformSource) {
+      await mcpUniformResources(server, this.uniformSource);
+    }
+    
+    if (token) {
+      await mcpUniformTools(server, this.uniformSource, token);
+    }
+
+    // Add simple token tool
+    this.addSimpleTokenTool(server);
+
+    // Connect to the MCP server
+    await server.connect(transport);
+
+    return transport;
+  }
+
+  // Simple method to add a token info tool
+  private addSimpleTokenTool(server: McpServer): void {
+    server.registerTool(
+      "get_token_info",
+      {
+        title: "Get Token Info",
+        description:
+          "Display information about the stored authentication token",
+        inputSchema: {},
+      },
+      async () => {
+        // Get all session info
+        const sessionCount = Object.keys(this.sessionTokens).length;
+        const sessions = Object.keys(this.sessionTokens);
+
+        if (sessionCount === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No authentication tokens found in any session",
+              },
+            ],
+          };
+        }
+
+        let result = `Found ${sessionCount} session(s) with tokens:\n\n`;
+
+        for (const sessionId of sessions) {
+          const token = this.sessionTokens[sessionId];
+          const maskedToken =
+            token.length > 10
+              ? `${token.substring(0, 6)}...${token.substring(token.length - 4)}`
+              : "***";
+
+          result += `Session: ${sessionId}\n`;
+          result += `Token (masked): ${maskedToken}\n`;
+          result += `Token length: ${token.length} characters\n\n`;
+        }
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: result,
+            },
+          ],
+        };
+      }
+    );
+  }
+
+  // Method to get token for a specific session
+  public getSessionToken(sessionId: string): string | undefined {
+    return this.sessionTokens[sessionId];
+  }
+
+  // Method to get active session count
+  private getActiveSessionCount(): number {
+    return Object.keys(this.transports).length;
+  }
+
+  // Method to clean up a specific session
+  private cleanupSession(sessionId: string): boolean {
+    if (this.transports[sessionId]) {
+      delete this.transports[sessionId];
+      delete this.sessionTokens[sessionId];
+      return true;
+    }
+    return false;
+  }
+
+  // Method to clean up all sessions
+  private cleanupAllSessions(): void {
+    this.transports = {};
+    this.sessionTokens = {};
+  }
+}