@mgsoftwarebv/mg-dashboard-mcp 2.3.0 → 2.3.2

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { createServer } from 'http';
+import { randomUUID, createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
 import { createClient } from '@supabase/supabase-js';
-import { createHash, randomBytes, createCipheriv, createDecipheriv } from 'crypto';
 import { Client } from 'ssh2';
 
 // src/trigger-tools.ts
@@ -1213,6 +1215,8 @@ var supabaseKey = getArg("supabase-key") || process.env.SUPABASE_SERVICE_ROLE_KE
 var encryptionKey = getArg("encryption-key") || process.env.ENCRYPTION_KEY;
 var mijnhostApiKey = getArg("mijnhost-api-key") || process.env.MIJNHOST_API_KEY;
 var agentWorkspaceId = getArg("workspace-id") || process.env.AGENT_WORKSPACE_ID || null;
+var httpMode = args.includes("--http");
+var httpPort = Number(getArg("port")) || 3100;
 if (!apiKey) {
   console.error("API key is required. Use --api-key=dk_xxx or set MG_DASHBOARD_API_KEY");
   process.exit(1);
@@ -2474,11 +2478,8 @@ var TOOLS = [
   // ----- Agent Reporting -----
   ...AGENT_TOOLS
 ];
-var server = new Server(
-  { name: "mg-dashboard-mcp", version: "2.2.0" },
-  { capabilities: { tools: {} } }
-);
-server.setRequestHandler(ListToolsRequestSchema, async () => {
+var MCP_VERSION = "2.3.1";
+async function handleListTools() {
   if (!authContext) return { tools: TOOLS };
   const accessible = TOOLS.filter((tool) => {
     const requiredModule = TOOL_MODULE_MAP[tool.name];
@@ -2486,8 +2487,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
     return authContext.permissions.modules[requiredModule] === true;
   });
   return { tools: accessible };
-});
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
+}
+async function handleCallTool(request) {
   if (!authContext) {
     return { content: [{ type: "text", text: "Error: not authenticated" }] };
   }
@@ -2935,7 +2936,17 @@ ${lines.join("\n")}` }] };
     const message = err instanceof Error ? err.message : String(err);
     return { content: [{ type: "text", text: `Error: ${message}` }] };
   }
-});
+}
+function createMcpServer() {
+  const s = new Server(
+    { name: "mg-dashboard-mcp", version: MCP_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  s.setRequestHandler(ListToolsRequestSchema, handleListTools);
+  s.setRequestHandler(CallToolRequestSchema, handleCallTool);
+  return s;
+}
+var server = createMcpServer();
 async function main() {
   console.error("Starting MG Dashboard MCP Server...");
   authContext = await validateApiKey(apiKey);
@@ -2943,10 +2954,105 @@ async function main() {
     console.error("API key validation failed");
     process.exit(1);
   }
-  console.error("API key validated. Starting stdio transport...");
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("MCP Server ready. Tools available: " + TOOLS.map((t) => t.name).join(", "));
+  const toolNames = TOOLS.map((t) => t.name).join(", ");
+  if (httpMode) {
+    console.error(`API key validated. Starting Streamable HTTP transport on port ${httpPort}...`);
+    const transports = /* @__PURE__ */ new Map();
+    const REST_TOOL_MAP = {
+      "/api/report-coverage": "agent-report-coverage",
+      "/api/report-finding": "agent-report-finding",
+      "/api/save-documentation": "agent-save-documentation",
+      "/api/list-findings": "agent-list-findings",
+      "/api/get-documentation": "agent-get-documentation"
+    };
+    const httpServer = createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://localhost:${httpPort}`);
+      const restToolName = REST_TOOL_MAP[url.pathname];
+      if (restToolName && req.method === "POST") {
+        const chunks = [];
+        for await (const chunk of req) chunks.push(chunk);
+        let toolArgs;
+        try {
+          toolArgs = JSON.parse(Buffer.concat(chunks).toString());
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid JSON" }));
+          return;
+        }
+        try {
+          const result = await handleAgentTool(restToolName, toolArgs, { supabase, workspaceId: agentWorkspaceId });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ ok: true, result }));
+        } catch (err) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+        }
+        return;
+      }
+      if (url.pathname === "/api/tools" && req.method === "GET") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ tools: Object.keys(REST_TOOL_MAP) }));
+        return;
+      }
+      if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not found");
+        return;
+      }
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, DELETE, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, mcp-session-id",
+          "Access-Control-Expose-Headers": "mcp-session-id"
+        });
+        res.end();
+        return;
+      }
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
+      const sessionId = req.headers["mcp-session-id"];
+      let body;
+      if (req.method === "POST") {
+        const chunks = [];
+        for await (const chunk of req) chunks.push(chunk);
+        try {
+          body = JSON.parse(Buffer.concat(chunks).toString());
+        } catch {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid JSON");
+          return;
+        }
+      }
+      if (sessionId && transports.has(sessionId)) {
+        await transports.get(sessionId).handleRequest(req, res, body);
+        return;
+      }
+      if (req.method === "POST" && body && (Array.isArray(body) ? body.some(isInitializeRequest) : isInitializeRequest(body))) {
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID()
+        });
+        transport.onclose = () => {
+          if (transport.sessionId) transports.delete(transport.sessionId);
+        };
+        const sessionServer = createMcpServer();
+        await sessionServer.connect(transport);
+        if (transport.sessionId) transports.set(transport.sessionId, transport);
+        await transport.handleRequest(req, res, body);
+        return;
+      }
+      res.writeHead(400, { "Content-Type": "text/plain" });
+      res.end("Bad request \u2014 missing or invalid session");
+    });
+    httpServer.listen(httpPort, () => {
+      console.error(`MCP HTTP server ready on port ${httpPort}. Tools: ${toolNames}`);
+    });
+  } else {
+    console.error("API key validated. Starting stdio transport...");
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`MCP Server ready. Tools: ${toolNames}`);
+  }
 }
 main().catch((err) => {
   console.error("Fatal error:", err);