@arabold/docs-mcp-server 1.10.0 → 1.12.0

package/dist/server.js

@@ -1,34 +1,153 @@
 #!/usr/bin/env node
-import {
-  CancelJobTool,
-  DEFAULT_MAX_DEPTH,
-  DEFAULT_MAX_PAGES,
-  DocumentManagementService,
-  FetchUrlTool,
-  FileFetcher,
-  FindVersionTool,
-  GetJobInfoTool,
-  HttpFetcher,
-  ListJobsTool,
-  ListLibrariesTool,
-  PipelineJobStatus,
-  PipelineManager,
-  RemoveTool,
-  ScrapeTool,
-  SearchTool,
-  VersionNotFoundError,
-  logger,
-  setLogLevel
-} from "./chunk-VTO2ED43.js";
-import "./chunk-YCXNASA6.js";
-
-// src/mcp/index.ts
 import "dotenv/config";
+import { program } from "commander";
+import { l as logger, P as PipelineJobStatus, D as DocumentManagementService, a as PipelineManager, b as DEFAULT_MAX_DEPTH, c as DEFAULT_MAX_PAGES, L as LibraryNotFoundError, V as VersionNotFoundError, s as setLogLevel, d as LogLevel, H as HttpFetcher, F as FileFetcher, S as SearchTool, e as ScrapeTool, f as ListLibrariesTool, g as DEFAULT_PROTOCOL, h as DEFAULT_HTTP_PORT } from "./DocumentManagementService-_qCZ1Hi2.js";
+import * as http from "node:http";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 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
+import "cheerio";
+import "node:vm";
+import "jsdom";
+import "playwright";
+import "@joplin/turndown-plugin-gfm";
+import "turndown";
+import "semver";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { F as FetchUrlTool, a as FindVersionTool } from "./FindVersionTool-CH1c3Tyu.js";
+import { R as RemoveTool, L as ListJobsTool } from "./RemoveTool-DmB1YJTA.js";
+class CancelJobTool {
+  manager;
+  /**
+   * Creates an instance of CancelJobTool.
+   * @param manager The PipelineManager instance.
+   */
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Executes the tool to attempt cancellation of a specific job.
+   * @param input - The input parameters, containing the jobId.
+   * @returns A promise that resolves with the outcome message.
+   */
+  async execute(input) {
+    try {
+      const job = await this.manager.getJob(input.jobId);
+      if (!job) {
+        logger.warn(`[CancelJobTool] Job not found: ${input.jobId}`);
+        return {
+          message: `Job with ID ${input.jobId} not found.`,
+          success: false
+        };
+      }
+      if (job.status === PipelineJobStatus.COMPLETED || // Use enum member
+      job.status === PipelineJobStatus.FAILED || // Use enum member
+      job.status === PipelineJobStatus.CANCELLED) {
+        logger.info(
+          `[CancelJobTool] Job ${input.jobId} is already in a final state: ${job.status}.`
+        );
+        return {
+          message: `Job ${input.jobId} is already ${job.status}. No action taken.`,
+          success: true
+          // Considered success as no cancellation needed
+        };
+      }
+      await this.manager.cancelJob(input.jobId);
+      const updatedJob = await this.manager.getJob(input.jobId);
+      const finalStatus = updatedJob?.status ?? "UNKNOWN (job disappeared?)";
+      logger.info(
+        `[CancelJobTool] Cancellation requested for job ${input.jobId}. Current status: ${finalStatus}`
+      );
+      return {
+        message: `Cancellation requested for job ${input.jobId}. Current status: ${finalStatus}.`,
+        success: true
+      };
+    } catch (error) {
+      logger.error(`[CancelJobTool] Error cancelling job ${input.jobId}: ${error}`);
+      return {
+        message: `Failed to cancel job ${input.jobId}: ${error instanceof Error ? error.message : String(error)}`,
+        success: false
+      };
+    }
+  }
+}
+class GetJobInfoTool {
+  manager;
+  /**
+   * Creates an instance of GetJobInfoTool.
+   * @param manager The PipelineManager instance.
+   */
+  constructor(manager) {
+    this.manager = manager;
+  }
+  /**
+   * Executes the tool to retrieve simplified info for a specific job.
+   * @param input - The input parameters, containing the jobId.
+   * @returns A promise that resolves with the simplified job info or null if not found.
+   */
+  async execute(input) {
+    const job = await this.manager.getJob(input.jobId);
+    if (!job) {
+      return { job: null };
+    }
+    const jobInfo = {
+      id: job.id,
+      library: job.library,
+      version: job.version,
+      status: job.status,
+      createdAt: job.createdAt.toISOString(),
+      startedAt: job.startedAt?.toISOString() ?? null,
+      finishedAt: job.finishedAt?.toISOString() ?? null,
+      error: job.error?.message ?? null
+    };
+    return { job: jobInfo };
+  }
+}
+let docService;
+let 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;
+}
 function createResponse(text) {
   return {
     content: [
@@ -51,177 +170,177 @@ function createError(text) {
     isError: true
   };
 }
-
-// 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),
-      // FetchUrlTool now uses middleware pipeline internally
-      fetchUrl: new FetchUrlTool(new HttpFetcher(), new FileFetcher())
-    };
-    const server = new McpServer(
-      {
-        name: "docs-mcp-server",
-        version: "0.1.0"
-      },
-      {
-        capabilities: {
-          tools: {},
-          prompts: {},
-          resources: {}
-        }
+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(`🚀 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}
 `
-          );
+        );
+        if (formattedResults.length === 0) {
           return createResponse(
-            `Search results for '${query}' in ${library} v${version}:
-${formattedResults.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)}`
+            `No results found for '${query}' in ${library}. Try to use a different or more general query.`
           );
         }
-      }
-    );
-    server.tool("list_libraries", "List all indexed libraries", {}, async () => {
-      try {
-        const result = await tools.listLibraries.execute();
         return createResponse(
-          `Indexed libraries:
-${result.libraries.map((lib) => `- ${lib.name}`).join("\n")}`
+          `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(" ")
+          );
+        }
+        if (error instanceof VersionNotFoundError) {
+          const indexedVersions = error.availableVersions.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 list libraries: ${error instanceof Error ? error.message : String(error)}`
+          `Failed to search documentation: ${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_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 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}
@@ -229,244 +348,421 @@ ${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;
+}
+async function startHttpServer(tools, port) {
+  setLogLevel(LogLevel.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(`🤖 Docs MCP server listening at http://127.0.0.1:${port}`);
+  });
+  return server;
+}
+async function startStdioServer(tools) {
+  setLogLevel(LogLevel.ERROR);
+  const server = createMcpServerInstance(tools);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("🤖 Docs MCP server listening on stdio");
+  return server;
+}
+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;
+}
+let runningServer = null;
+let runningPipelineManager = null;
+let runningDocService = null;
+async function startServer(protocol, port) {
+  try {
+    setLogLevel(LogLevel.ERROR);
+    await initializeServices();
+    runningDocService = getDocService();
+    runningPipelineManager = getPipelineManager();
+    const tools = await initializeTools();
+    let serverInstance;
+    if (protocol === "stdio") {
+      serverInstance = 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");
+      serverInstance = await startHttpServer(tools, port);
+    } else {
+      logger.error(`Unknown protocol: ${protocol}`);
+      process.exit(1);
+    }
+    runningServer = serverInstance;
     process.on("SIGINT", async () => {
-      await pipelineManager.stop();
-      await docService.shutdown();
-      await server.close();
+      logger.info("Received SIGINT. Shutting down gracefully...");
+      await stopServer();
       process.exit(0);
     });
   } catch (error) {
-    await docService.shutdown();
-    logger.error(`\u274C Fatal Error: ${error}`);
+    logger.error(`❌ Fatal Error during server startup: ${error}`);
+    await stopServer();
     process.exit(1);
   }
 }
-
-// src/server.ts
-startServer().catch((error) => {
-  logger.error(`\u274C Fatal Error: ${error}`);
-  process.exit(1);
-});
-//# sourceMappingURL=server.js.map
+async function stopServer() {
+  logger.info("Shutting down MCP server and services...");
+  let hadError = false;
+  try {
+    if (runningPipelineManager) {
+      logger.debug("Stopping Pipeline Manager...");
+      await runningPipelineManager.stop();
+      logger.info("Pipeline Manager stopped.");
+    }
+  } catch (e) {
+    logger.error(`Error stopping Pipeline Manager: ${e}`);
+    hadError = true;
+  }
+  try {
+    if (runningDocService) {
+      logger.debug("Shutting down Document Service...");
+      await runningDocService.shutdown();
+      logger.info("Document Service shut down.");
+    }
+  } catch (e) {
+    logger.error(`Error shutting down Document Service: ${e}`);
+    hadError = true;
+  }
+  try {
+    if (runningServer) {
+      logger.debug("Closing MCP Server connection...");
+      await runningServer.close();
+      logger.info("MCP Server connection closed.");
+    }
+  } catch (e) {
+    logger.error(`Error closing MCP Server: ${e}`);
+    hadError = true;
+  }
+  runningPipelineManager = null;
+  runningDocService = null;
+  runningServer = null;
+  if (hadError) {
+    logger.warn("Server shutdown completed with errors.");
+  } else {
+    logger.info("✅ Server shutdown complete.");
+  }
+}
+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);
+const options = program.opts();
+async function main() {
+  const protocol = options.protocol;
+  const port = process.env.MCP_PORT ? Number.parseInt(process.env.MCP_PORT, 10) : 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