npm - @arabold/docs-mcp-server - Versions diffs - 1.9.0 → 1.11.0 - Mend

@arabold/docs-mcp-server 1.9.0 → 1.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +85 -241
package/dist/{chunk-A5FW7XVC.js → chunk-VF2RUEVV.js} +779 -280
package/dist/chunk-VF2RUEVV.js.map +1 -0
package/dist/cli.js +46 -17
package/dist/cli.js.map +1 -1
package/dist/server.js +567 -366
package/dist/server.js.map +1 -1
package/package.json +6 -7
package/dist/chunk-A5FW7XVC.js.map +0 -1

package/dist/server.js CHANGED Viewed

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import {
   CancelJobTool,
+  DEFAULT_HTTP_PORT,
   DEFAULT_MAX_DEPTH,
   DEFAULT_MAX_PAGES,
+  DEFAULT_PROTOCOL,
   DocumentManagementService,
   FetchUrlTool,
   FileFetcher,
   FindVersionTool,
   GetJobInfoTool,
-  HtmlProcessor,
   HttpFetcher,
+  LibraryNotFoundError,
   ListJobsTool,
   ListLibrariesTool,
   PipelineJobStatus,
@@ -20,13 +22,68 @@ import {
   VersionNotFoundError,
   logger,
   setLogLevel
-} from "./chunk-A5FW7XVC.js";
+} from "./chunk-VF2RUEVV.js";
 import "./chunk-YCXNASA6.js";
+// src/server.ts
+import { program } from "commander";
 // src/mcp/index.ts
 import "dotenv/config";
+// src/mcp/services.ts
+var docService;
+var pipelineManager;
+async function initializeServices() {
+  if (docService || pipelineManager) {
+    logger.warn("Services already initialized.");
+    return;
+  }
+  docService = new DocumentManagementService();
+  try {
+    await docService.initialize();
+    logger.debug("DocumentManagementService initialized.");
+    pipelineManager = new PipelineManager(docService);
+    await pipelineManager.start();
+    logger.debug("PipelineManager initialized and started.");
+  } catch (error) {
+    logger.error(`Failed to initialize services: ${error}`);
+    await shutdownServices();
+    throw error;
+  }
+}
+async function shutdownServices() {
+  if (pipelineManager) {
+    await pipelineManager.stop();
+    logger.info("PipelineManager stopped.");
+    pipelineManager = void 0;
+  }
+  if (docService) {
+    await docService.shutdown();
+    logger.info("DocumentManagementService shutdown.");
+    docService = void 0;
+  }
+}
+function getDocService() {
+  if (!docService) {
+    throw new Error("DocumentManagementService has not been initialized.");
+  }
+  return docService;
+}
+function getPipelineManager() {
+  if (!pipelineManager) {
+    throw new Error("PipelineManager has not been initialized.");
+  }
+  return pipelineManager;
+}
+// src/mcp/startHttpServer.ts
+import * as http from "node:http";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+// src/mcp/mcpServer.ts
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
 // src/mcp/utils.ts
@@ -53,179 +110,176 @@ function createError(text) {
   };
 }
-// src/mcp/index.ts
-async function startServer() {
-  setLogLevel(0 /* ERROR */);
-  const docService = new DocumentManagementService();
-  try {
-    await docService.initialize();
-    const pipelineManager = new PipelineManager(docService);
-    await pipelineManager.start();
-    const tools = {
-      listLibraries: new ListLibrariesTool(docService),
-      findVersion: new FindVersionTool(docService),
-      scrape: new ScrapeTool(docService, pipelineManager),
-      search: new SearchTool(docService),
-      listJobs: new ListJobsTool(pipelineManager),
-      getJobInfo: new GetJobInfoTool(pipelineManager),
-      cancelJob: new CancelJobTool(pipelineManager),
-      remove: new RemoveTool(docService),
-      fetchUrl: new FetchUrlTool(
-        new HttpFetcher(),
-        new FileFetcher(),
-        new HtmlProcessor()
-      )
-    };
-    const server = new McpServer(
-      {
-        name: "docs-mcp-server",
-        version: "0.1.0"
-      },
-      {
-        capabilities: {
-          tools: {},
-          prompts: {},
-          resources: {}
-        }
+// src/mcp/mcpServer.ts
+function createMcpServerInstance(tools) {
+  const server = new McpServer(
+    {
+      name: "docs-mcp-server",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        prompts: {},
+        resources: {}
       }
-    );
-    server.tool(
-      "scrape_docs",
-      "Scrape and index documentation from a URL",
-      {
-        url: z.string().url().describe("URL of the documentation to scrape"),
-        library: z.string().describe("Name of the library"),
-        version: z.string().optional().describe("Version of the library"),
-        maxPages: z.number().optional().default(DEFAULT_MAX_PAGES).describe(`Maximum number of pages to scrape (default: ${DEFAULT_MAX_PAGES})`),
-        maxDepth: z.number().optional().default(DEFAULT_MAX_DEPTH).describe(`Maximum navigation depth (default: ${DEFAULT_MAX_DEPTH})`),
-        scope: z.enum(["subpages", "hostname", "domain"]).optional().default("subpages").describe("Defines the crawling boundary: 'subpages', 'hostname', or 'domain'"),
-        followRedirects: z.boolean().optional().default(true).describe("Whether to follow HTTP redirects (3xx responses)")
-      },
-      async ({ url, library, version, maxPages, maxDepth, scope, followRedirects }) => {
-        try {
-          const result = await tools.scrape.execute({
-            url,
-            library,
-            version,
-            waitForCompletion: false,
-            // Don't wait for completion
-            // onProgress: undefined, // Explicitly undefined or omitted
-            options: {
-              maxPages,
-              maxDepth,
-              scope,
-              followRedirects
-            }
-          });
-          if ("jobId" in result) {
-            return createResponse(`\u{1F680} Scraping job started with ID: ${result.jobId}.`);
+    }
+  );
+  server.tool(
+    "scrape_docs",
+    "Scrape and index documentation from a URL",
+    {
+      url: z.string().url().describe("URL of the documentation to scrape"),
+      library: z.string().describe("Name of the library"),
+      version: z.string().optional().describe("Version of the library"),
+      maxPages: z.number().optional().default(DEFAULT_MAX_PAGES).describe(`Maximum number of pages to scrape (default: ${DEFAULT_MAX_PAGES})`),
+      maxDepth: z.number().optional().default(DEFAULT_MAX_DEPTH).describe(`Maximum navigation depth (default: ${DEFAULT_MAX_DEPTH})`),
+      scope: z.enum(["subpages", "hostname", "domain"]).optional().default("subpages").describe("Defines the crawling boundary: 'subpages', 'hostname', or 'domain'"),
+      followRedirects: z.boolean().optional().default(true).describe("Whether to follow HTTP redirects (3xx responses)")
+    },
+    async ({ url, library, version, maxPages, maxDepth, scope, followRedirects }) => {
+      try {
+        const result = await tools.scrape.execute({
+          url,
+          library,
+          version,
+          waitForCompletion: false,
+          // Don't wait for completion
+          // onProgress: undefined, // Explicitly undefined or omitted
+          options: {
+            maxPages,
+            maxDepth,
+            scope,
+            followRedirects
           }
-          return createResponse(
-            `Scraping finished immediately (unexpectedly) with ${result.pagesScraped} pages.`
-          );
-        } catch (error) {
-          return createError(
-            `Failed to scrape documentation: ${error instanceof Error ? error.message : String(error)}`
-          );
+        });
+        if ("jobId" in result) {
+          return createResponse(`\u{1F680} Scraping job started with ID: ${result.jobId}.`);
         }
+        return createResponse(
+          `Scraping finished immediately (unexpectedly) with ${result.pagesScraped} pages.`
+        );
+      } catch (error) {
+        return createError(
+          `Failed to scrape documentation: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.tool(
-      "search_docs",
-      'Search indexed documentation. Examples:\n- {library: "react", query: "how do hooks work"} -> matches latest version of React\n- {library: "react", version: "18.0.0", query: "how do hooks work"} -> matches React 18.0.0 or earlier\n- {library: "typescript", version: "5.x", query: "ReturnType example"} -> any TypeScript 5.x.x version\n- {library: "typescript", version: "5.2.x", query: "ReturnType example"} -> any TypeScript 5.2.x version',
-      {
-        library: z.string().describe("Name of the library"),
-        version: z.string().optional().describe(
-          "Version of the library (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
-        ),
-        query: z.string().describe("Search query"),
-        limit: z.number().optional().default(5).describe("Maximum number of results")
-      },
-      async ({ library, version, query, limit }) => {
-        try {
-          const result = await tools.search.execute({
-            library,
-            version,
-            query,
-            limit,
-            exactMatch: false
-            // Always false for MCP interface
-          });
-          const formattedResults = result.results.map(
-            (r, i) => `
+    }
+  );
+  server.tool(
+    "search_docs",
+    'Searches up-to-date documentation for a library. Examples:\n\n- {library: "react", query: "hooks lifecycle"} -> matches latest version of React\n- {library: "react", version: "18.0.0", query: "hooks lifecycle"} -> matches React 18.0.0 or earlier\n- {library: "typescript", version: "5.x", query: "ReturnType example"} -> any TypeScript 5.x.x version\n- {library: "typescript", version: "5.2.x", query: "ReturnType example"} -> any TypeScript 5.2.x version',
+    {
+      library: z.string().describe("Name of the library"),
+      version: z.string().optional().describe(
+        "Version of the library (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
+      ),
+      query: z.string().describe("Search query"),
+      limit: z.number().optional().default(5).describe("Maximum number of results")
+    },
+    async ({ library, version, query, limit }) => {
+      try {
+        const result = await tools.search.execute({
+          library,
+          version,
+          query,
+          limit,
+          exactMatch: false
+          // Always false for MCP interface
+        });
+        const formattedResults = result.results.map(
+          (r, i) => `
 ------------------------------------------------------------
 Result ${i + 1}: ${r.url}
 ${r.content}
 `
-          );
-          return createResponse(
-            `Search results for '${query}' in ${library} v${version}:
+        );
+        if (formattedResults.length === 0) {
+          return createResponse(`No results found for '${query}' in ${library}.`);
+        }
+        return createResponse(
+          `Search results for '${query}' in ${library}:
 ${formattedResults.join("")}`
+        );
+      } catch (error) {
+        if (error instanceof LibraryNotFoundError) {
+          return createResponse(
+            [
+              `Library "${library}" not found.`,
+              error.suggestions?.length ? `Did you mean: ${error.suggestions?.join(", ")}?` : void 0
+            ].join(" ")
           );
-        } catch (error) {
-          if (error instanceof VersionNotFoundError) {
-            const indexedVersions = error.availableVersions.filter((v) => v.indexed).map((v) => v.version);
-            return createError(
-              indexedVersions.length > 0 ? `Version not found. Available indexed versions for ${library}: ${indexedVersions.join(", ")}` : `Version not found. No indexed versions available for ${library}.`
-            );
-          }
-          return createError(
-            `Failed to search documentation: ${error instanceof Error ? error.message : String(error)}`
+        }
+        if (error instanceof VersionNotFoundError) {
+          const indexedVersions = error.availableVersions.filter((v) => v.indexed).map((v) => v.version);
+          return createResponse(
+            [
+              `Version "${version}" not found.`,
+              indexedVersions.length > 0 ? `Available indexed versions for ${library}: ${indexedVersions.join(", ")}` : void 0
+            ].join(" ")
           );
         }
+        return createError(
+          `Failed to search documentation: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.tool("list_libraries", "List all indexed libraries", {}, async () => {
-      try {
-        const result = await tools.listLibraries.execute();
-        return createResponse(
-          `Indexed libraries:
+    }
+  );
+  server.tool("list_libraries", "List all indexed libraries", {}, async () => {
+    try {
+      const result = await tools.listLibraries.execute();
+      if (result.libraries.length === 0) {
+        return createResponse("No libraries indexed yet.");
+      }
+      return createResponse(
+        `Indexed libraries:
 ${result.libraries.map((lib) => `- ${lib.name}`).join("\n")}`
-        );
+      );
+    } catch (error) {
+      return createError(
+        `Failed to list libraries: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  });
+  server.tool(
+    "find_version",
+    "Find best matching version for a library",
+    {
+      library: z.string().describe("Name of the library"),
+      targetVersion: z.string().optional().describe(
+        "Pattern to match (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
+      )
+    },
+    async ({ library, targetVersion }) => {
+      try {
+        const message = await tools.findVersion.execute({
+          library,
+          targetVersion
+        });
+        if (!message) {
+          return createError("No matching version found");
+        }
+        return createResponse(message);
       } catch (error) {
         return createError(
-          `Failed to list libraries: ${error instanceof Error ? error.message : String(error)}`
+          `Failed to find version: ${error instanceof Error ? error.message : String(error)}`
         );
       }
-    });
-    server.tool(
-      "find_version",
-      "Find best matching version for a library",
-      {
-        library: z.string().describe("Name of the library"),
-        targetVersion: z.string().optional().describe(
-          "Target version to match (supports exact versions like '18.0.0' or X-Range patterns like '5.x', '5.2.x')"
-        )
-      },
-      async ({ library, targetVersion }) => {
-        try {
-          const version = await tools.findVersion.execute({
-            library,
-            targetVersion
-          });
-          if (!version) {
-            return createError("No matching version found");
-          }
-          return createResponse(`Found matching version: ${version}`);
-        } catch (error) {
-          return createError(
-            `Failed to find version: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    );
-    server.tool(
-      "list_jobs",
-      "List pipeline jobs, optionally filtering by status.",
-      {
-        status: z.nativeEnum(PipelineJobStatus).optional().describe("Optional status to filter jobs by.")
-      },
-      async ({ status }) => {
-        try {
-          const result = await tools.listJobs.execute({ status });
-          const formattedJobs = result.jobs.map(
-            (job) => `- ID: ${job.id}
+    }
+  );
+  server.tool(
+    "list_jobs",
+    "List pipeline jobs, optionally filtering by status.",
+    {
+      status: z.nativeEnum(PipelineJobStatus).optional().describe("Optional status to filter jobs by.")
+    },
+    async ({ status }) => {
+      try {
+        const result = await tools.listJobs.execute({ status });
+        const formattedJobs = result.jobs.map(
+          (job) => `- ID: ${job.id}
   Status: ${job.status}
   Library: ${job.library}
   Version: ${job.version}
@@ -233,244 +287,391 @@ ${result.libraries.map((lib) => `- ${lib.name}`).join("\n")}`
   Started: ${job.startedAt}` : ""}${job.finishedAt ? `
   Finished: ${job.finishedAt}` : ""}${job.error ? `
   Error: ${job.error}` : ""}`
-          ).join("\n\n");
-          return createResponse(
-            result.jobs.length > 0 ? `Current Jobs:
+        ).join("\n\n");
+        return createResponse(
+          result.jobs.length > 0 ? `Current Jobs:
-${formattedJobs}` : "No jobs found matching criteria."
-          );
-        } catch (error) {
-          return createError(
-            `Failed to list jobs: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+${formattedJobs}` : "No jobs found."
+        );
+      } catch (error) {
+        return createError(
+          `Failed to list jobs: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.tool(
-      "get_job_info",
-      "Get the simplified info for a specific pipeline job.",
-      {
-        jobId: z.string().uuid().describe("The ID of the job to query.")
-      },
-      async ({ jobId }) => {
-        try {
-          const result = await tools.getJobInfo.execute({ jobId });
-          if (!result.job) {
-            return createError(`Job with ID ${jobId} not found.`);
-          }
-          const job = result.job;
-          const formattedJob = `- ID: ${job.id}
+    }
+  );
+  server.tool(
+    "get_job_info",
+    "Get the simplified info for a specific pipeline job.",
+    {
+      jobId: z.string().uuid().describe("The ID of the job to query.")
+    },
+    async ({ jobId }) => {
+      try {
+        const result = await tools.getJobInfo.execute({ jobId });
+        if (!result.job) {
+          return createError(`Job with ID ${jobId} not found.`);
+        }
+        const job = result.job;
+        const formattedJob = `- ID: ${job.id}
   Status: ${job.status}
   Library: ${job.library}@${job.version}
   Created: ${job.createdAt}${job.startedAt ? `
   Started: ${job.startedAt}` : ""}${job.finishedAt ? `
   Finished: ${job.finishedAt}` : ""}${job.error ? `
   Error: ${job.error}` : ""}`;
-          return createResponse(`Job Info:
+        return createResponse(`Job Info:
 ${formattedJob}`);
-        } catch (error) {
-          return createError(
-            `Failed to get job info for ${jobId}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    );
-    server.tool(
-      "fetch_url",
-      "Fetch a single URL and convert its content to Markdown",
-      {
-        url: z.string().url().describe("The URL to fetch and convert to markdown"),
-        followRedirects: z.boolean().optional().default(true).describe("Whether to follow HTTP redirects (3xx responses)")
-      },
-      async ({ url, followRedirects }) => {
-        try {
-          const result = await tools.fetchUrl.execute({ url, followRedirects });
-          return createResponse(result);
-        } catch (error) {
-          return createError(
-            `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+      } catch (error) {
+        return createError(
+          `Failed to get job info for ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.tool(
-      "cancel_job",
-      "Attempt to cancel a queued or running pipeline job.",
-      {
-        jobId: z.string().uuid().describe("The ID of the job to cancel.")
-      },
-      async ({ jobId }) => {
-        try {
-          const result = await tools.cancelJob.execute({ jobId });
-          if (result.success) {
-            return createResponse(result.message);
-          }
-          return createError(result.message);
-        } catch (error) {
-          return createError(
-            `Failed to cancel job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
+    }
+  );
+  server.tool(
+    "fetch_url",
+    "Fetch a single URL and convert its content to Markdown",
+    {
+      url: z.string().url().describe("The URL to fetch and convert to markdown"),
+      followRedirects: z.boolean().optional().default(true).describe("Whether to follow HTTP redirects (3xx responses)")
+    },
+    async ({ url, followRedirects }) => {
+      try {
+        const result = await tools.fetchUrl.execute({ url, followRedirects });
+        return createResponse(result);
+      } catch (error) {
+        return createError(
+          `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.tool(
-      "remove_docs",
-      "Remove indexed documentation for a library version.",
-      {
-        library: z.string().describe("Name of the library"),
-        version: z.string().optional().describe("Version of the library (optional, removes unversioned if omitted)")
-      },
-      async ({ library, version }) => {
-        try {
-          const result = await tools.remove.execute({ library, version });
+    }
+  );
+  server.tool(
+    "cancel_job",
+    "Attempt to cancel a queued or running pipeline job.",
+    {
+      jobId: z.string().uuid().describe("The ID of the job to cancel.")
+    },
+    async ({ jobId }) => {
+      try {
+        const result = await tools.cancelJob.execute({ jobId });
+        if (result.success) {
           return createResponse(result.message);
-        } catch (error) {
-          return createError(
-            `Failed to remove documents: ${error instanceof Error ? error.message : String(error)}`
-          );
         }
+        return createError(result.message);
+      } catch (error) {
+        return createError(
+          `Failed to cancel job ${jobId}: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.prompt(
-      "docs",
-      "Search indexed documentation",
-      {
-        library: z.string().describe("Name of the library"),
-        version: z.string().optional().describe("Version of the library"),
-        query: z.string().describe("Search query")
-      },
-      async ({ library, version, query }) => {
-        return {
-          messages: [
-            {
-              role: "user",
-              content: {
-                type: "text",
-                text: `Please search ${library} ${version || ""} documentation for this query: ${query}`
-              }
-            }
-          ]
-        };
+    }
+  );
+  server.tool(
+    "remove_docs",
+    "Remove indexed documentation for a library version.",
+    {
+      library: z.string().describe("Name of the library"),
+      version: z.string().optional().describe("Version of the library (optional, removes unversioned if omitted)")
+    },
+    async ({ library, version }) => {
+      try {
+        const result = await tools.remove.execute({ library, version });
+        return createResponse(result.message);
+      } catch (error) {
+        return createError(
+          `Failed to remove documents: ${error instanceof Error ? error.message : String(error)}`
+        );
       }
-    );
-    server.resource(
-      "libraries",
-      "docs://libraries",
-      {
-        description: "List all indexed libraries"
-      },
-      async (uri) => {
-        const result = await tools.listLibraries.execute();
-        return {
-          contents: result.libraries.map((lib) => ({
-            uri: new URL(lib.name, uri).href,
-            text: lib.name
-          }))
-        };
+    }
+  );
+  server.prompt(
+    "docs",
+    "Search indexed documentation",
+    {
+      library: z.string().describe("Name of the library"),
+      version: z.string().optional().describe("Version of the library"),
+      query: z.string().describe("Search query")
+    },
+    async ({ library, version, query }) => {
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Please search ${library} ${version || ""} documentation for this query: ${query}`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.resource(
+    "libraries",
+    "docs://libraries",
+    {
+      description: "List all indexed libraries"
+    },
+    async (uri) => {
+      const result = await tools.listLibraries.execute();
+      return {
+        contents: result.libraries.map((lib) => ({
+          uri: new URL(lib.name, uri).href,
+          text: lib.name
+        }))
+      };
+    }
+  );
+  server.resource(
+    "versions",
+    new ResourceTemplate("docs://libraries/{library}/versions", {
+      list: void 0
+    }),
+    {
+      description: "List all indexed versions for a library"
+    },
+    async (uri, { library }) => {
+      const result = await tools.listLibraries.execute();
+      const lib = result.libraries.find((l) => l.name === library);
+      if (!lib) {
+        return { contents: [] };
       }
-    );
-    server.resource(
-      "versions",
-      new ResourceTemplate("docs://libraries/{library}/versions", {
-        list: void 0
-      }),
-      {
-        description: "List all indexed versions for a library"
-      },
-      async (uri, { library }) => {
-        const result = await tools.listLibraries.execute();
-        const lib = result.libraries.find((l) => l.name === library);
-        if (!lib) {
-          return { contents: [] };
+      return {
+        contents: lib.versions.map((v) => ({
+          uri: new URL(v.version, uri).href,
+          text: v.version
+        }))
+      };
+    }
+  );
+  server.resource(
+    "jobs",
+    "docs://jobs",
+    {
+      description: "List pipeline jobs, optionally filtering by status.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const statusParam = uri.searchParams.get("status");
+      let statusFilter;
+      if (statusParam) {
+        const validation = z.nativeEnum(PipelineJobStatus).safeParse(statusParam);
+        if (validation.success) {
+          statusFilter = validation.data;
+        } else {
+          logger.warn(`Invalid status parameter received: ${statusParam}`);
         }
-        return {
-          contents: lib.versions.map((v) => ({
-            uri: new URL(v.version, uri).href,
-            text: v.version
-          }))
-        };
       }
-    );
-    server.resource(
-      "jobs",
-      "docs://jobs",
-      {
-        description: "List pipeline jobs, optionally filtering by status.",
-        mimeType: "application/json"
-      },
-      async (uri) => {
-        const statusParam = uri.searchParams.get("status");
-        let statusFilter;
-        if (statusParam) {
-          const validation = z.nativeEnum(PipelineJobStatus).safeParse(statusParam);
-          if (validation.success) {
-            statusFilter = validation.data;
-          } else {
-            logger.warn(`Invalid status parameter received: ${statusParam}`);
+      const result = await tools.listJobs.execute({ status: statusFilter });
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result.jobs, null, 2)
+            // Stringify the simplified jobs array
           }
-        }
-        const result = await tools.listJobs.execute({ status: statusFilter });
-        return {
-          contents: [
-            {
-              uri: uri.href,
-              mimeType: "application/json",
-              text: JSON.stringify(result.jobs, null, 2)
-              // Stringify the simplified jobs array
-            }
-          ]
-        };
+        ]
+      };
+    }
+  );
+  server.resource(
+    "job",
+    // A distinct name for this specific resource type
+    new ResourceTemplate("docs://jobs/{jobId}", { list: void 0 }),
+    {
+      description: "Get details for a specific pipeline job by ID.",
+      mimeType: "application/json"
+    },
+    async (uri, { jobId }) => {
+      if (typeof jobId !== "string" || jobId.length === 0) {
+        logger.warn(`Invalid jobId received in URI: ${jobId}`);
+        return { contents: [] };
       }
-    );
-    server.resource(
-      "job",
-      // A distinct name for this specific resource type
-      new ResourceTemplate("docs://jobs/{jobId}", { list: void 0 }),
-      {
-        description: "Get details for a specific pipeline job by ID.",
-        mimeType: "application/json"
-      },
-      async (uri, { jobId }) => {
-        if (typeof jobId !== "string" || jobId.length === 0) {
-          logger.warn(`Invalid jobId received in URI: ${jobId}`);
-          return { contents: [] };
+      const result = await tools.getJobInfo.execute({ jobId });
+      if (!result.job) {
+        return { contents: [] };
+      }
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result.job, null, 2)
+            // Stringify the simplified job object
+          }
+        ]
+      };
+    }
+  );
+  return server;
+}
+// src/mcp/startHttpServer.ts
+async function startHttpServer(tools, port) {
+  setLogLevel(2 /* INFO */);
+  const server = createMcpServerInstance(tools);
+  const sseTransports = {};
+  const httpServer = http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || "/", `http://${req.headers.host}`);
+      if (req.method === "GET" && url.pathname === "/sse") {
+        const transport = new SSEServerTransport("/messages", res);
+        sseTransports[transport.sessionId] = transport;
+        res.on("close", () => {
+          delete sseTransports[transport.sessionId];
+          transport.close();
+        });
+        await server.connect(transport);
+      } else if (req.method === "POST" && url.pathname === "/messages") {
+        const sessionId = url.searchParams.get("sessionId");
+        const transport = sessionId ? sseTransports[sessionId] : void 0;
+        if (transport) {
+          let body = "";
+          for await (const chunk of req) {
+            body += chunk;
+          }
+          const parsedBody = JSON.parse(body);
+          await transport.handlePostMessage(req, res, parsedBody);
+        } else {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "No transport found for sessionId" }));
         }
-        const result = await tools.getJobInfo.execute({ jobId });
-        if (!result.job) {
-          return { contents: [] };
+      } else if (url.pathname === "/mcp") {
+        let body = "";
+        for await (const chunk of req) {
+          body += chunk;
         }
-        return {
-          contents: [
-            {
-              uri: uri.href,
-              mimeType: "application/json",
-              text: JSON.stringify(result.job, null, 2)
-              // Stringify the simplified job object
-            }
-          ]
-        };
+        const parsedBody = JSON.parse(body);
+        const requestServer = createMcpServerInstance(tools);
+        const requestTransport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: void 0
+        });
+        res.on("close", () => {
+          logger.info("Streamable HTTP request closed");
+          requestTransport.close();
+          requestServer.close();
+        });
+        await requestServer.connect(requestTransport);
+        await requestTransport.handleRequest(req, res, parsedBody);
+      } else {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            error: `Endpoint ${url.pathname} not found.`
+          })
+        );
+      }
+    } catch (error) {
+      logger.error(`Error handling HTTP request: ${error}`);
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: error instanceof Error ? error.message : String(error)
+        })
+      );
+    }
+  });
+  httpServer.listen(port, () => {
+    logger.info(`Documentation MCP server running on http://0.0.0.0:${port}`);
+  });
+  process.removeAllListeners("SIGINT");
+  process.on("SIGINT", async () => {
+    logger.info("Shutting down HTTP server...");
+    await shutdownServices();
+    await server.close();
+    httpServer.close();
+    logger.info("HTTP server closed.");
+    process.exit(0);
+  });
+}
+// src/mcp/startStdioServer.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function startStdioServer(tools) {
+  setLogLevel(0 /* ERROR */);
+  const server = createMcpServerInstance(tools);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("Documentation MCP server running on stdio");
+  process.removeAllListeners("SIGINT");
+  process.on("SIGINT", async () => {
+    logger.info("Shutting down Stdio server...");
+    await shutdownServices();
+    await server.close();
+    logger.info("Stdio server closed.");
+    process.exit(0);
+  });
+}
+// src/mcp/tools.ts
+async function initializeTools() {
+  const docService2 = getDocService();
+  const pipelineManager2 = getPipelineManager();
+  const tools = {
+    listLibraries: new ListLibrariesTool(docService2),
+    findVersion: new FindVersionTool(docService2),
+    scrape: new ScrapeTool(docService2, pipelineManager2),
+    search: new SearchTool(docService2),
+    listJobs: new ListJobsTool(pipelineManager2),
+    getJobInfo: new GetJobInfoTool(pipelineManager2),
+    cancelJob: new CancelJobTool(pipelineManager2),
+    remove: new RemoveTool(docService2),
+    // FetchUrlTool now uses middleware pipeline internally
+    fetchUrl: new FetchUrlTool(new HttpFetcher(), new FileFetcher())
+  };
+  return tools;
+}
+// src/mcp/index.ts
+async function startServer(protocol, port) {
+  try {
+    await initializeServices();
+    const tools = await initializeTools();
+    if (protocol === "stdio") {
+      await startStdioServer(tools);
+    } else if (protocol === "http") {
+      if (port === void 0) {
+        logger.error("HTTP protocol requires a port.");
+        process.exit(1);
       }
-    );
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    logger.info("Documentation MCP server running on stdio");
-    process.on("SIGINT", async () => {
-      await pipelineManager.stop();
-      await docService.shutdown();
-      await server.close();
-      process.exit(0);
-    });
+      await startHttpServer(tools, port);
+    } else {
+      logger.error(`Unknown protocol: ${protocol}`);
+      process.exit(1);
+    }
   } catch (error) {
-    await docService.shutdown();
     logger.error(`\u274C Fatal Error: ${error}`);
     process.exit(1);
   }
 }
 // src/server.ts
-startServer().catch((error) => {
-  logger.error(`\u274C Fatal Error: ${error}`);
-  process.exit(1);
-});
+program.option("--protocol <type>", "Protocol to use (stdio or http)", DEFAULT_PROTOCOL).option(
+  "--port <number>",
+  "Port to listen on for http protocol",
+  `${DEFAULT_HTTP_PORT}`
+).parse(process.argv);
+var options = program.opts();
+async function main() {
+  const protocol = options.protocol;
+  const port = Number.parseInt(options.port, 10);
+  if (protocol !== "stdio" && protocol !== "http") {
+    console.error('Invalid protocol specified. Use "stdio" or "http".');
+    process.exit(1);
+  }
+  if (protocol === "http" && Number.isNaN(port)) {
+    console.error("Port must be a number when using http protocol.");
+    process.exit(1);
+  }
+  try {
+    await startServer(protocol, protocol === "http" ? port : void 0);
+  } catch (error) {
+    console.error(`Server failed to start: ${error}`);
+    process.exit(1);
+  }
+}
+main();
 //# sourceMappingURL=server.js.map