docusaurus-plugin-mcp-server 0.7.0 → 0.9.0

package/dist/adapters-entry.js

@@ -3,10 +3,10 @@
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
 var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
 var webStandardStreamableHttp_js = require('@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js');
-var zod = require('zod');
 var FlexSearch = require('flexsearch');
 var fs = require('fs-extra');
-require('http');
+var zod = require('zod');
+var http = require('http');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -81,6 +81,8 @@ function searchIndex(index, docs, query, options = {}) {
     const doc = docs[docId];
     if (!doc) continue;
     results.push({
+      url: docId,
+      // docId is the full URL when indexed with baseUrl
       route: doc.route,
       title: doc.title,
       score,
@@ -188,16 +190,11 @@ var FlexSearchProvider = class {
     const limit = options?.limit ?? 5;
     return searchIndex(this.searchIndex, this.docs, query, { limit });
   }
-  async getDocument(route) {
+  async getDocument(url) {
     if (!this.docs) {
       throw new Error("[FlexSearch] Provider not initialized");
     }
-    if (this.docs[route]) {
-      return this.docs[route];
-    }
-    const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
-    const withoutSlash = route.startsWith("/") ? route.slice(1) : route;
-    return this.docs[normalizedRoute] ?? this.docs[withoutSlash] ?? null;
+    return this.docs[url] ?? null;
   }
   async healthCheck() {
     if (!this.isReady()) {
@@ -262,9 +259,16 @@ function isSearchProvider(obj) {
   const provider = obj;
   return typeof provider.name === "string" && typeof provider.initialize === "function" && typeof provider.isReady === "function" && typeof provider.search === "function";
 }
-
-// src/mcp/tools/docs-search.ts
-function formatSearchResults(results, baseUrl) {
+var docsSearchInputSchema = {
+  query: zod.z.string().min(1).describe("The search query string"),
+  limit: zod.z.number().int().min(1).max(20).optional().default(5).describe("Maximum number of results to return (1-20, default: 5)")
+};
+var docsSearchTool = {
+  name: "docs_search",
+  description: "Search the documentation for relevant pages. Returns matching documents with URLs, snippets, and relevance scores. Use this to find information across all documentation.",
+  inputSchema: docsSearchInputSchema
+};
+function formatSearchResults(results) {
   if (results.length === 0) {
     return "No matching documents found.";
   }
@@ -274,24 +278,29 @@ function formatSearchResults(results, baseUrl) {
     const result = results[i];
     if (!result) continue;
     lines.push(`${i + 1}. **${result.title}**`);
-    if (baseUrl) {
-      const fullUrl = `${baseUrl.replace(/\/$/, "")}${result.route}`;
-      lines.push(`   URL: ${fullUrl}`);
-    }
-    lines.push(`   Route: ${result.route}`);
+    lines.push(`   URL: ${result.url}`);
     if (result.matchingHeadings && result.matchingHeadings.length > 0) {
       lines.push(`   Matching sections: ${result.matchingHeadings.join(", ")}`);
     }
     lines.push(`   ${result.snippet}`);
     lines.push("");
   }
+  lines.push("Use docs_fetch with the URL to retrieve the full page content.");
   return lines.join("\n");
 }
-
-// src/mcp/tools/docs-get-page.ts
-function formatPageContent(doc, baseUrl) {
+var docsFetchInputSchema = {
+  url: zod.z.string().url().describe(
+    'The full URL of the page to fetch (e.g., "https://docs.example.com/docs/getting-started")'
+  )
+};
+var docsFetchTool = {
+  name: "docs_fetch",
+  description: "Fetch the complete content of a documentation page. Use this after searching to get the full markdown content of a specific page.",
+  inputSchema: docsFetchInputSchema
+};
+function formatPageContent(doc) {
   if (!doc) {
-    return "Page not found. Please check the route path and try again.";
+    return "Page not found. Please check the URL and try again.";
   }
   const lines = [];
   lines.push(`# ${doc.title}`);
@@ -300,12 +309,6 @@ function formatPageContent(doc, baseUrl) {
     lines.push(`> ${doc.description}`);
     lines.push("");
   }
-  if (baseUrl) {
-    const fullUrl = `${baseUrl.replace(/\/$/, "")}${doc.route}`;
-    lines.push(`**URL:** ${fullUrl}`);
-  }
-  lines.push(`**Route:** ${doc.route}`);
-  lines.push("");
   if (doc.headings.length > 0) {
     lines.push("## Contents");
     lines.push("");
@@ -323,43 +326,6 @@ function formatPageContent(doc, baseUrl) {
   return lines.join("\n");
 }
 
-// src/processing/heading-extractor.ts
-function extractSection(markdown, headingId, headings) {
-  const heading = headings.find((h) => h.id === headingId);
-  if (!heading) {
-    return null;
-  }
-  return markdown.slice(heading.startOffset, heading.endOffset).trim();
-}
-
-// src/mcp/tools/docs-get-section.ts
-function formatSectionContent(result, headingId, baseUrl) {
-  if (!result.doc) {
-    return "Page not found. Please check the route path and try again.";
-  }
-  if (!result.content) {
-    const lines2 = [`Section "${headingId}" not found in this document.`, "", "Available sections:"];
-    for (const heading of result.availableHeadings) {
-      const indent = "  ".repeat(heading.level - 1);
-      lines2.push(`${indent}- ${heading.text} (id: ${heading.id})`);
-    }
-    return lines2.join("\n");
-  }
-  const lines = [];
-  const fullUrl = baseUrl ? `${baseUrl.replace(/\/$/, "")}${result.doc.route}#${headingId}` : null;
-  lines.push(`# ${result.headingText}`);
-  if (fullUrl) {
-    lines.push(`> From: ${result.doc.title} - ${fullUrl}`);
-  } else {
-    lines.push(`> From: ${result.doc.title} (${result.doc.route})`);
-  }
-  lines.push("");
-  lines.push("---");
-  lines.push("");
-  lines.push(result.content);
-  return lines.join("\n");
-}
-
 // src/mcp/server.ts
 function isFileConfig(config) {
   return "docsPath" in config && "indexPath" in config;
@@ -388,17 +354,14 @@ var McpDocsServer = class {
     this.registerTools();
   }
   /**
-   * Register all MCP tools using the SDK's registerTool API
+   * Register all MCP tools using definitions from tool files
    */
   registerTools() {
     this.mcpServer.registerTool(
-      "docs_search",
+      docsSearchTool.name,
       {
-        description: "Search the documentation for relevant pages. Returns matching documents with snippets and relevance scores. Use this to find information across all documentation.",
-        inputSchema: {
-          query: zod.z.string().min(1).describe("The search query string"),
-          limit: zod.z.number().int().min(1).max(20).optional().default(5).describe("Maximum number of results to return (1-20, default: 5)")
-        }
+        description: docsSearchTool.description,
+        inputSchema: docsSearchTool.inputSchema
       },
       async ({ query, limit }) => {
         await this.initialize();
@@ -411,9 +374,7 @@ var McpDocsServer = class {
         try {
           const results = await this.searchProvider.search(query, { limit });
           return {
-            content: [
-              { type: "text", text: formatSearchResults(results, this.config.baseUrl) }
-            ]
+            content: [{ type: "text", text: formatSearchResults(results) }]
           };
         } catch (error) {
           console.error("[MCP] Search error:", error);
@@ -425,47 +386,12 @@ var McpDocsServer = class {
       }
     );
     this.mcpServer.registerTool(
-      "docs_get_page",
-      {
-        description: "Retrieve the complete content of a documentation page as markdown. Use this when you need the full content of a specific page.",
-        inputSchema: {
-          route: zod.z.string().min(1).describe('The page route path (e.g., "/docs/getting-started" or "/api/reference")')
-        }
-      },
-      async ({ route }) => {
-        await this.initialize();
-        if (!this.searchProvider || !this.searchProvider.isReady()) {
-          return {
-            content: [{ type: "text", text: "Server not initialized. Please try again." }],
-            isError: true
-          };
-        }
-        try {
-          const doc = await this.getDocument(route);
-          return {
-            content: [{ type: "text", text: formatPageContent(doc, this.config.baseUrl) }]
-          };
-        } catch (error) {
-          console.error("[MCP] Get page error:", error);
-          return {
-            content: [{ type: "text", text: `Error getting page: ${String(error)}` }],
-            isError: true
-          };
-        }
-      }
-    );
-    this.mcpServer.registerTool(
-      "docs_get_section",
+      docsFetchTool.name,
       {
-        description: "Retrieve a specific section from a documentation page by its heading ID. Use this when you need only a portion of a page rather than the entire content.",
-        inputSchema: {
-          route: zod.z.string().min(1).describe("The page route path"),
-          headingId: zod.z.string().min(1).describe(
-            'The heading ID of the section to extract (e.g., "installation", "api-reference")'
-          )
-        }
+        description: docsFetchTool.description,
+        inputSchema: docsFetchTool.inputSchema
       },
-      async ({ route, headingId }) => {
+      async ({ url }) => {
         await this.initialize();
         if (!this.searchProvider || !this.searchProvider.isReady()) {
           return {
@@ -474,58 +400,14 @@ var McpDocsServer = class {
           };
         }
         try {
-          const doc = await this.getDocument(route);
-          if (!doc) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: formatSectionContent(
-                    { content: null, doc: null, headingText: null, availableHeadings: [] },
-                    headingId,
-                    this.config.baseUrl
-                  )
-                }
-              ]
-            };
-          }
-          const availableHeadings = doc.headings.map((h) => ({
-            id: h.id,
-            text: h.text,
-            level: h.level
-          }));
-          const heading = doc.headings.find((h) => h.id === headingId.trim());
-          if (!heading) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: formatSectionContent(
-                    { content: null, doc, headingText: null, availableHeadings },
-                    headingId,
-                    this.config.baseUrl
-                  )
-                }
-              ]
-            };
-          }
-          const sectionContent = extractSection(doc.markdown, headingId.trim(), doc.headings);
+          const doc = await this.getDocument(url);
           return {
-            content: [
-              {
-                type: "text",
-                text: formatSectionContent(
-                  { content: sectionContent, doc, headingText: heading.text, availableHeadings },
-                  headingId,
-                  this.config.baseUrl
-                )
-              }
-            ]
+            content: [{ type: "text", text: formatPageContent(doc) }]
           };
         } catch (error) {
-          console.error("[MCP] Get section error:", error);
+          console.error("[MCP] Fetch error:", error);
           return {
-            content: [{ type: "text", text: `Error getting section: ${String(error)}` }],
+            content: [{ type: "text", text: `Error fetching page: ${String(error)}` }],
             isError: true
           };
         }
@@ -533,24 +415,14 @@ var McpDocsServer = class {
     );
   }
   /**
-   * Get a document by route using the search provider
+   * Get a document by URL using the search provider
    */
-  async getDocument(route) {
+  async getDocument(url) {
     if (!this.searchProvider) {
       return null;
     }
     if (this.searchProvider.getDocument) {
-      return this.searchProvider.getDocument(route);
-    }
-    if (this.searchProvider instanceof FlexSearchProvider) {
-      const docs = this.searchProvider.getDocs();
-      if (!docs) return null;
-      if (docs[route]) {
-        return docs[route];
-      }
-      const normalizedRoute = route.startsWith("/") ? route : `/${route}`;
-      const withoutSlash = route.startsWith("/") ? route.slice(1) : route;
-      return docs[normalizedRoute] ?? docs[withoutSlash] ?? null;
+      return this.searchProvider.getDocument(url);
     }
     return null;
   }
@@ -669,6 +541,16 @@ var McpDocsServer = class {
   }
 };
 
+// src/adapters/cors.ts
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type"
+};
+function getCorsHeaders() {
+  return { ...CORS_HEADERS };
+}
+
 // src/adapters/vercel.ts
 function createVercelHandler(config) {
   let server = null;
@@ -679,12 +561,24 @@ function createVercelHandler(config) {
     return server;
   }
   return async function handler(req, res) {
+    const corsHeaders = getCorsHeaders();
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, corsHeaders);
+      res.end();
+      return;
+    }
     if (req.method === "GET") {
+      Object.entries(corsHeaders).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
       const mcpServer = getServer();
       const status = await mcpServer.getStatus();
       return res.status(200).json(status);
     }
     if (req.method !== "POST") {
+      Object.entries(corsHeaders).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
       return res.status(405).json({
         jsonrpc: "2.0",
         id: null,
@@ -695,6 +589,9 @@ function createVercelHandler(config) {
       });
     }
     try {
+      Object.entries(corsHeaders).forEach(([key, value]) => {
+        res.setHeader(key, value);
+      });
       const mcpServer = getServer();
       await mcpServer.handleHttpRequest(req, res, req.body);
     } catch (error) {
@@ -731,8 +628,8 @@ function eventToRequest(event) {
     body: event.httpMethod !== "GET" && event.httpMethod !== "HEAD" ? body : void 0
   });
 }
-async function responseToNetlify(response) {
-  const headers = {};
+async function responseToNetlify(response, additionalHeaders) {
+  const headers = { ...additionalHeaders };
   response.headers.forEach((value, key) => {
     headers[key] = value;
   });
@@ -752,9 +649,17 @@ function createNetlifyHandler(config) {
     return server;
   }
   return async function handler(event, _context) {
+    const corsHeaders = getCorsHeaders();
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      ...corsHeaders
     };
+    if (event.httpMethod === "OPTIONS") {
+      return {
+        statusCode: 204,
+        headers: corsHeaders
+      };
+    }
     if (event.httpMethod === "GET") {
       const mcpServer = getServer();
       const status = await mcpServer.getStatus();
@@ -782,7 +687,7 @@ function createNetlifyHandler(config) {
       const mcpServer = getServer();
       const request = eventToRequest(event);
       const response = await mcpServer.handleWebRequest(request);
-      return await responseToNetlify(response);
+      return await responseToNetlify(response, corsHeaders);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error("MCP Server Error:", error);
@@ -819,20 +724,16 @@ function createCloudflareHandler(config) {
     return server;
   }
   return async function fetch(request) {
-    const headers = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type"
-    };
+    const corsHeaders = getCorsHeaders();
     if (request.method === "OPTIONS") {
-      return new Response(null, { status: 204, headers });
+      return new Response(null, { status: 204, headers: corsHeaders });
     }
     if (request.method === "GET") {
       const mcpServer = getServer();
       const status = await mcpServer.getStatus();
       return new Response(JSON.stringify(status), {
         status: 200,
-        headers: { ...headers, "Content-Type": "application/json" }
+        headers: { ...corsHeaders, "Content-Type": "application/json" }
       });
     }
     if (request.method !== "POST") {
@@ -847,7 +748,7 @@ function createCloudflareHandler(config) {
         }),
         {
           status: 405,
-          headers: { ...headers, "Content-Type": "application/json" }
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
         }
       );
     }
@@ -855,7 +756,7 @@ function createCloudflareHandler(config) {
       const mcpServer = getServer();
       const response = await mcpServer.handleWebRequest(request);
       const newHeaders = new Headers(response.headers);
-      Object.entries(headers).forEach(([key, value]) => {
+      Object.entries(corsHeaders).forEach(([key, value]) => {
         newHeaders.set(key, value);
       });
       return new Response(response.body, {
@@ -877,7 +778,7 @@ function createCloudflareHandler(config) {
         }),
         {
           status: 500,
-          headers: { ...headers, "Content-Type": "application/json" }
+          headers: { ...corsHeaders, "Content-Type": "application/json" }
         }
       );
     }
@@ -1041,9 +942,102 @@ compatibility_date = "2024-01-01"
     }
   ];
 }
+function createNodeHandler(options) {
+  const { corsOrigin = "*", ...config } = options;
+  let server = null;
+  function getServer() {
+    if (!server) {
+      server = new McpDocsServer(config);
+    }
+    return server;
+  }
+  function setCorsHeaders(res) {
+    if (corsOrigin !== false) {
+      res.setHeader("Access-Control-Allow-Origin", corsOrigin);
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    }
+  }
+  return async function handler(req, res) {
+    setCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method === "GET") {
+      try {
+        const mcpServer = getServer();
+        const status = await mcpServer.getStatus();
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(status, null, 2));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: message }));
+      }
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32600,
+            message: "Method not allowed. Use POST for MCP requests, GET for status."
+          }
+        })
+      );
+      return;
+    }
+    try {
+      const body = await parseRequestBody(req);
+      const mcpServer = getServer();
+      await mcpServer.handleHttpRequest(req, res, body);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error("[MCP] Request error:", error);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: null,
+          error: {
+            code: -32603,
+            message: `Internal server error: ${message}`
+          }
+        })
+      );
+    }
+  };
+}
+function createNodeServer(options) {
+  const handler = createNodeHandler(options);
+  return http.createServer(handler);
+}
+async function parseRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => {
+      try {
+        resolve(body ? JSON.parse(body) : void 0);
+      } catch {
+        reject(new Error("Invalid JSON in request body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
 
 exports.createCloudflareHandler = createCloudflareHandler;
 exports.createNetlifyHandler = createNetlifyHandler;
+exports.createNodeHandler = createNodeHandler;
+exports.createNodeServer = createNodeServer;
 exports.createVercelHandler = createVercelHandler;
 exports.generateAdapterFiles = generateAdapterFiles;
 //# sourceMappingURL=adapters-entry.js.map