@arabold/docs-mcp-server 1.14.0 → 1.15.0

package/dist/server.js

@@ -1,769 +0,0 @@
-#!/usr/bin/env node
-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-BZ_ZZgPI.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 { z } from "zod";
-import "cheerio";
-import "node:vm";
-import "jsdom";
-import "playwright";
-import "@joplin/turndown-plugin-gfm";
-import "turndown";
-import "node:util";
-import "semver";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { F as FetchUrlTool, a as FindVersionTool } from "./FindVersionTool-Dfw5Lbql.js";
-import { R as RemoveTool, L as ListJobsTool } from "./RemoveTool-w8KGOaXw.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: [
-      {
-        type: "text",
-        text
-      }
-    ],
-    isError: false
-  };
-}
-function createError(text) {
-  return {
-    content: [
-      {
-        type: "text",
-        text
-      }
-    ],
-    isError: true
-  };
-}
-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(`🚀 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",
-    '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(
-            `No results found for '${query}' in ${library}. Try to use a different or more general query.`
-          );
-        }
-        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(" ")
-          );
-        }
-        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 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();
-      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}
-  Status: ${job.status}
-  Library: ${job.library}
-  Version: ${job.version}
-  Created: ${job.createdAt}${job.startedAt ? `
-  Started: ${job.startedAt}` : ""}${job.finishedAt ? `
-  Finished: ${job.finishedAt}` : ""}${job.error ? `
-  Error: ${job.error}` : ""}`
-        ).join("\n\n");
-        return createResponse(
-          result.jobs.length > 0 ? `Current Jobs:
-
-${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}
-  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:
-
-${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)}`
-        );
-      }
-    }
-  );
-  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(
-    "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.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: [] };
-      }
-      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
-          }
-        ]
-      };
-    }
-  );
-  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" }));
-        }
-      } else if (url.pathname === "/mcp") {
-        let body = "";
-        for await (const chunk of req) {
-          body += chunk;
-        }
-        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);
-      }
-      serverInstance = await startHttpServer(tools, port);
-    } else {
-      logger.error(`Unknown protocol: ${protocol}`);
-      process.exit(1);
-    }
-    runningServer = serverInstance;
-    process.on("SIGINT", async () => {
-      logger.info("Received SIGINT. Shutting down gracefully...");
-      await stopServer();
-      process.exit(0);
-    });
-  } catch (error) {
-    logger.error(`❌ Fatal Error during server startup: ${error}`);
-    await stopServer();
-    process.exit(1);
-  }
-}
-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