dynamic-openapi-mcp 0.1.1

package/dist/cli.js

@@ -0,0 +1,1452 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/utils/fetch.ts
+var DEFAULT_OPTIONS = {
+  timeout: 3e4,
+  retries: 3,
+  retryDelay: 1e3,
+  retryOn: [429, 500, 502, 503, 504]
+};
+async function fetchWithRetry(url, init, opts) {
+  const { timeout, retries, retryDelay, retryOn } = { ...DEFAULT_OPTIONS, ...opts };
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        ...init,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (retryOn.includes(response.status) && attempt < retries) {
+        const retryAfter = response.headers.get("Retry-After");
+        const delay = retryAfter ? parseRetryAfter(retryAfter) : retryDelay * Math.pow(2, attempt);
+        await sleep(delay);
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (lastError.name === "AbortError") {
+        lastError = new Error(`Request timed out after ${timeout}ms: ${url}`);
+      }
+      if (attempt < retries) {
+        await sleep(retryDelay * Math.pow(2, attempt));
+        continue;
+      }
+    }
+  }
+  throw lastError ?? new Error(`Request failed after ${retries + 1} attempts: ${url}`);
+}
+function parseRetryAfter(value) {
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds)) {
+    return Math.min(seconds * 1e3, 6e4);
+  }
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) {
+    return Math.min(Math.max(date - Date.now(), 0), 6e4);
+  }
+  return 1e3;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/auth/strategies.ts
+var BearerAuth = class {
+  constructor(token) {
+    this.token = token;
+  }
+  async apply(_url, init) {
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Bearer ${this.token}`);
+    return { ...init, headers };
+  }
+};
+var ApiKeyAuth = class {
+  constructor(key, paramName, location) {
+    this.key = key;
+    this.paramName = paramName;
+    this.location = location;
+  }
+  async apply(url, init) {
+    switch (this.location) {
+      case "header": {
+        const headers = new Headers(init.headers);
+        headers.set(this.paramName, this.key);
+        return { ...init, headers };
+      }
+      case "query": {
+        url.searchParams.set(this.paramName, this.key);
+        return init;
+      }
+      case "cookie": {
+        const headers = new Headers(init.headers);
+        const existing = headers.get("Cookie") ?? "";
+        const encodedKey = encodeURIComponent(this.paramName);
+        const encodedValue = encodeURIComponent(this.key);
+        const cookie = existing ? `${existing}; ${encodedKey}=${encodedValue}` : `${encodedKey}=${encodedValue}`;
+        headers.set("Cookie", cookie);
+        return { ...init, headers };
+      }
+    }
+  }
+};
+var BasicAuth = class {
+  constructor(username, password) {
+    this.username = username;
+    this.password = password;
+  }
+  async apply(_url, init) {
+    const credentials = `${this.username}:${this.password}`;
+    const encoded = Buffer.from(credentials, "utf-8").toString("base64");
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Basic ${encoded}`);
+    return { ...init, headers };
+  }
+};
+var OAuth2ClientCredentials = class {
+  constructor(clientId, clientSecret, tokenUrl, scopes = []) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.tokenUrl = tokenUrl;
+    this.scopes = scopes;
+  }
+  tokenCache = null;
+  pendingRefresh = null;
+  async apply(_url, init) {
+    const token = await this.getToken();
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    return { ...init, headers };
+  }
+  async getToken() {
+    if (this.tokenCache && Date.now() < this.tokenCache.expiresAt) {
+      return this.tokenCache.token;
+    }
+    if (this.pendingRefresh) {
+      return this.pendingRefresh;
+    }
+    this.pendingRefresh = this.fetchToken();
+    try {
+      return await this.pendingRefresh;
+    } finally {
+      this.pendingRefresh = null;
+    }
+  }
+  async fetchToken() {
+    const body = new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: this.clientId,
+      client_secret: this.clientSecret
+    });
+    if (this.scopes.length > 0) {
+      body.set("scope", this.scopes.join(" "));
+    }
+    const res = await fetchWithRetry(this.tokenUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    }, { retries: 2, timeout: 15e3 });
+    if (!res.ok) {
+      const errorBody = await res.text().catch(() => "");
+      throw new Error(
+        `OAuth2 token request failed: ${res.status} ${res.statusText}${errorBody ? ` - ${errorBody}` : ""}`
+      );
+    }
+    let data;
+    try {
+      data = await res.json();
+    } catch {
+      throw new Error("OAuth2 token response is not valid JSON");
+    }
+    if (typeof data.access_token !== "string" || !data.access_token) {
+      throw new Error('OAuth2 token response missing "access_token" field');
+    }
+    const expiresIn = typeof data.expires_in === "number" ? data.expires_in : 3600;
+    const bufferSeconds = Math.min(60, expiresIn * 0.1);
+    this.tokenCache = {
+      token: data.access_token,
+      expiresAt: Date.now() + (expiresIn - bufferSeconds) * 1e3
+    };
+    return data.access_token;
+  }
+};
+var CustomAuth = class {
+  constructor(handler) {
+    this.handler = handler;
+  }
+  async apply(url, init) {
+    return this.handler(url.toString(), init);
+  }
+};
+var CompositeAuth = class {
+  constructor(strategies) {
+    this.strategies = strategies;
+  }
+  async apply(url, init) {
+    let result = init;
+    for (const strategy of this.strategies) {
+      result = await strategy.apply(url, result);
+    }
+    return result;
+  }
+};
+function createAuthFromScheme(scheme, credential) {
+  switch (scheme.type) {
+    case "http": {
+      if (scheme.scheme === "bearer") {
+        return new BearerAuth(credential);
+      }
+      if (scheme.scheme === "basic") {
+        const colonIndex = credential.indexOf(":");
+        if (colonIndex === -1) {
+          return new BasicAuth(credential, "");
+        }
+        return new BasicAuth(credential.slice(0, colonIndex), credential.slice(colonIndex + 1));
+      }
+      return null;
+    }
+    case "apiKey": {
+      const location = scheme.in;
+      if (!["header", "query", "cookie"].includes(location)) {
+        return new ApiKeyAuth(credential, scheme.name, "header");
+      }
+      return new ApiKeyAuth(credential, scheme.name, location);
+    }
+    default:
+      return null;
+  }
+}
+
+// src/auth/resolver.ts
+function resolveAuth(config, securitySchemes) {
+  const strategies = [];
+  if (config?.custom) {
+    return new CustomAuth(config.custom);
+  }
+  if (config?.bearerToken) {
+    strategies.push(new BearerAuth(config.bearerToken));
+  }
+  if (config?.apiKey) {
+    const apiKeyScheme = Object.values(securitySchemes).find(
+      (s) => s.type === "apiKey"
+    );
+    if (apiKeyScheme) {
+      strategies.push(new ApiKeyAuth(config.apiKey, apiKeyScheme.name, apiKeyScheme.in));
+    } else {
+      strategies.push(new ApiKeyAuth(config.apiKey, "X-API-Key", "header"));
+    }
+  }
+  if (config?.basicAuth) {
+    strategies.push(new BasicAuth(config.basicAuth.username, config.basicAuth.password));
+  }
+  if (config?.oauth2) {
+    strategies.push(
+      new OAuth2ClientCredentials(
+        config.oauth2.clientId,
+        config.oauth2.clientSecret,
+        config.oauth2.tokenUrl,
+        config.oauth2.scopes
+      )
+    );
+  }
+  if (strategies.length > 0) {
+    return strategies.length === 1 ? strategies[0] : new CompositeAuth(strategies);
+  }
+  return resolveAuthFromEnv(securitySchemes);
+}
+function resolveAuthFromEnv(securitySchemes) {
+  for (const [name, scheme] of Object.entries(securitySchemes)) {
+    const envName = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+    const envToken = process.env[`OPENAPI_AUTH_${envName}_TOKEN`] ?? process.env[`OPENAPI_AUTH_${envName}_KEY`];
+    if (envToken) {
+      const auth = createAuthFromScheme(scheme, envToken);
+      if (auth) return auth;
+    }
+  }
+  const globalToken = process.env["OPENAPI_AUTH_TOKEN"];
+  if (globalToken) {
+    return new BearerAuth(globalToken);
+  }
+  const globalApiKey = process.env["OPENAPI_API_KEY"];
+  if (globalApiKey) {
+    const apiKeyScheme = Object.values(securitySchemes).find(
+      (s) => s.type === "apiKey"
+    );
+    if (apiKeyScheme) {
+      return new ApiKeyAuth(globalApiKey, apiKeyScheme.name, apiKeyScheme.in);
+    }
+    return new ApiKeyAuth(globalApiKey, "X-API-Key", "header");
+  }
+  return null;
+}
+
+// src/parser/loader.ts
+import { readFile } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+function resolveSource(source) {
+  if (typeof source !== "string") {
+    return { type: "inline", value: source };
+  }
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    return { type: "url", value: source };
+  }
+  if (source.trim().startsWith("{") || source.trim().startsWith("openapi")) {
+    return { type: "inline", value: source };
+  }
+  return { type: "file", value: source };
+}
+async function loadSpec(source) {
+  const resolved = resolveSource(source);
+  switch (resolved.type) {
+    case "url": {
+      const res = await fetchWithRetry(resolved.value);
+      if (!res.ok) {
+        throw new Error(`Failed to fetch spec from ${resolved.value}: ${res.status} ${res.statusText}`);
+      }
+      const text = await res.text();
+      return parseSpecText(text, resolved.value);
+    }
+    case "file": {
+      let text;
+      try {
+        text = await readFile(resolved.value, "utf-8");
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to read spec file "${resolved.value}": ${msg}`);
+      }
+      return parseSpecText(text, resolved.value);
+    }
+    case "inline": {
+      if (typeof resolved.value === "string") {
+        return parseSpecText(resolved.value, "(inline)");
+      }
+      return resolved.value;
+    }
+  }
+}
+function parseSpecText(text, source) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to parse JSON spec from ${source}: ${msg}`);
+    }
+  }
+  try {
+    return parseYaml(trimmed);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to parse YAML spec from ${source}: ${msg}`);
+  }
+}
+
+// src/parser/resolver.ts
+import { validate, dereference } from "@readme/openapi-parser";
+async function resolveSpec(doc) {
+  const validation = await validate(structuredClone(doc));
+  if (!validation.valid) {
+    const validationResult = validation;
+    const errors = validationResult.errors ?? [];
+    throw new Error(`Invalid OpenAPI spec: ${JSON.stringify(errors)}`);
+  }
+  const dereferenced = await dereference(structuredClone(doc));
+  const operations = extractOperations(dereferenced);
+  const schemas = extractSchemas(dereferenced);
+  const securitySchemes = extractSecuritySchemes(dereferenced);
+  const servers = extractServers(dereferenced);
+  const tags = extractTags(dereferenced);
+  const externalDocs = extractExternalDocs(dereferenced.externalDocs);
+  return {
+    title: dereferenced.info.title,
+    version: dereferenced.info.version,
+    description: dereferenced.info.description,
+    servers,
+    operations,
+    schemas,
+    securitySchemes,
+    tags,
+    externalDocs,
+    raw: dereferenced
+  };
+}
+var HTTP_METHODS = ["get", "post", "put", "delete", "patch", "head", "options", "trace"];
+function extractOperations(doc) {
+  const operations = [];
+  const paths = doc.paths ?? {};
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem) continue;
+    const pathParams = pathItem.parameters ?? [];
+    for (const method of HTTP_METHODS) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const operationParams = operation.parameters ?? [];
+      const allParams = mergeParameters(pathParams, operationParams);
+      const operationId = operation.operationId ?? generateOperationId(method, path);
+      const parameters = allParams.map((p) => ({
+        name: p.name,
+        in: p.in,
+        required: p.required ?? p.in === "path",
+        description: p.description,
+        schema: p.schema ?? { type: "string" },
+        example: p.example,
+        examples: p.examples ? extractExamples(p.examples) : void 0,
+        deprecated: p.deprecated
+      }));
+      let requestBody;
+      if (operation.requestBody) {
+        const rb = operation.requestBody;
+        const content = {};
+        for (const [mediaType, mediaObj] of Object.entries(rb.content ?? {})) {
+          if (mediaObj.schema) {
+            content[mediaType] = {
+              schema: mediaObj.schema,
+              example: mediaObj.example,
+              examples: mediaObj.examples ? extractExamples(mediaObj.examples) : void 0
+            };
+          }
+        }
+        requestBody = {
+          required: rb.required ?? false,
+          description: rb.description,
+          content
+        };
+      }
+      const responses = {};
+      for (const [code, resp] of Object.entries(operation.responses ?? {})) {
+        responses[code] = extractResponse(resp);
+      }
+      operations.push({
+        operationId,
+        method: method.toUpperCase(),
+        path,
+        summary: operation.summary,
+        description: operation.description,
+        deprecated: operation.deprecated,
+        parameters,
+        requestBody,
+        responses,
+        security: operation.security ?? doc.security ?? [],
+        tags: operation.tags ?? [],
+        externalDocs: extractExternalDocs(operation.externalDocs)
+      });
+    }
+  }
+  return operations;
+}
+function extractResponse(resp) {
+  const parsed = {
+    description: resp.description ?? "",
+    content: {}
+  };
+  if (resp.content) {
+    for (const [mediaType, mediaObj] of Object.entries(resp.content)) {
+      parsed.content[mediaType] = {
+        schema: mediaObj.schema
+      };
+      if (!parsed.schema && mediaObj.schema) {
+        parsed.schema = mediaObj.schema;
+        parsed.mediaType = mediaType;
+      }
+      if (parsed.example === void 0 && mediaObj.example !== void 0) {
+        parsed.example = mediaObj.example;
+      }
+      if (!parsed.examples && mediaObj.examples) {
+        parsed.examples = extractExamples(mediaObj.examples);
+      }
+    }
+  }
+  if (resp.links) {
+    parsed.links = extractLinks(resp.links);
+  }
+  return parsed;
+}
+function extractExamples(examples) {
+  const result = {};
+  for (const [name, ex] of Object.entries(examples)) {
+    result[name] = {
+      summary: ex.summary,
+      description: ex.description,
+      value: ex.value
+    };
+  }
+  return result;
+}
+function extractLinks(links) {
+  const result = {};
+  for (const [name, link] of Object.entries(links)) {
+    result[name] = {
+      operationId: link.operationId,
+      operationRef: link.operationRef,
+      parameters: link.parameters,
+      description: link.description
+    };
+  }
+  return result;
+}
+function generateOperationId(method, path) {
+  const cleaned = path.replace(/\{([^}]+)\}/g, "by_$1").replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+  return `${method}_${cleaned}`.toLowerCase();
+}
+function mergeParameters(pathParams, operationParams) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const p of pathParams) {
+    merged.set(`${p.in}:${p.name}`, p);
+  }
+  for (const p of operationParams) {
+    merged.set(`${p.in}:${p.name}`, p);
+  }
+  return Array.from(merged.values());
+}
+function extractSchemas(doc) {
+  const schemas = {};
+  const components = doc.components?.schemas ?? {};
+  for (const [name, schema] of Object.entries(components)) {
+    schemas[name] = schema;
+  }
+  return schemas;
+}
+function extractSecuritySchemes(doc) {
+  const schemes = {};
+  const components = doc.components?.securitySchemes ?? {};
+  for (const [name, scheme] of Object.entries(components)) {
+    schemes[name] = scheme;
+  }
+  return schemes;
+}
+function extractServers(doc) {
+  return (doc.servers ?? []).map((s) => {
+    const server = { url: s.url };
+    if (s.description) server.description = s.description;
+    if (s.variables) {
+      server.variables = {};
+      for (const [name, v] of Object.entries(s.variables)) {
+        server.variables[name] = {
+          default: v.default,
+          enum: v.enum,
+          description: v.description
+        };
+      }
+    }
+    return server;
+  });
+}
+function extractTags(doc) {
+  return (doc.tags ?? []).map((t) => {
+    const tag = { name: t.name };
+    if (t.description) tag.description = t.description;
+    if (t.externalDocs) {
+      tag.externalDocs = {
+        url: t.externalDocs.url,
+        description: t.externalDocs.description
+      };
+    }
+    return tag;
+  });
+}
+function extractExternalDocs(docs) {
+  if (!docs) return void 0;
+  return {
+    url: docs.url,
+    description: docs.description
+  };
+}
+
+// src/http/response-handler.ts
+async function handleResponse(response) {
+  const contentType = response.headers.get("content-type") ?? "";
+  const status = response.status;
+  if (status === 204) {
+    return [{ type: "text", text: "No Content (204)" }];
+  }
+  if (contentType.includes("image/")) {
+    const buffer = await response.arrayBuffer();
+    const base64 = Buffer.from(buffer).toString("base64");
+    return [
+      {
+        type: "image",
+        data: base64,
+        mimeType: contentType.split(";")[0].trim()
+      }
+    ];
+  }
+  const text = await response.text();
+  if (contentType.includes("json")) {
+    try {
+      const parsed = JSON.parse(text);
+      return [{ type: "text", text: JSON.stringify(parsed, null, 2) }];
+    } catch {
+    }
+  }
+  return [{ type: "text", text: text || `(empty response, status ${status})` }];
+}
+
+// src/http/client.ts
+function resolveServerUrl(server, variableOverrides) {
+  let url = server.url;
+  if (server.variables) {
+    for (const [name, variable] of Object.entries(server.variables)) {
+      const value = variableOverrides?.[name] ?? variable.default;
+      if (variable.enum && !variable.enum.includes(value)) {
+        throw new Error(`Invalid value "${value}" for server variable "${name}". Allowed: ${variable.enum.join(", ")}`);
+      }
+      url = url.replaceAll(`{${name}}`, value);
+    }
+  }
+  return normalizeUrl(url);
+}
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+function resolveBaseUrl(spec, overrideBaseUrl, serverIndex) {
+  if (overrideBaseUrl) return overrideBaseUrl.replace(/\/$/, "");
+  const index = serverIndex ?? 0;
+  const server = spec.servers[index];
+  if (server) {
+    return resolveServerUrl(server);
+  }
+  throw new Error("No server URL found in spec and no baseUrl provided");
+}
+async function executeOperation(operation, args, config) {
+  const validationErrors = validateRequiredParams(operation, args);
+  if (validationErrors.length > 0) {
+    return [{ type: "text", text: `Validation errors:
+${validationErrors.join("\n")}` }];
+  }
+  let path = operation.path;
+  for (const param of operation.parameters) {
+    if (param.in === "path" && args[param.name] !== void 0) {
+      const value = encodeURIComponent(String(args[param.name]));
+      path = path.replaceAll(`{${param.name}}`, value);
+    }
+  }
+  const url = new URL(`${config.baseUrl}${path}`);
+  for (const param of operation.parameters) {
+    if (param.in === "query" && args[param.name] !== void 0) {
+      const val = args[param.name];
+      if (Array.isArray(val)) {
+        for (const item of val) {
+          url.searchParams.append(param.name, String(item));
+        }
+      } else {
+        url.searchParams.set(param.name, String(val));
+      }
+    }
+  }
+  const headers = new Headers(config.defaultHeaders);
+  const produces = getResponseMediaTypes(operation);
+  headers.set("Accept", produces.length > 0 ? produces.join(", ") : "application/json");
+  for (const param of operation.parameters) {
+    if (param.in === "header" && args[param.name] !== void 0) {
+      headers.set(param.name, String(args[param.name]));
+    }
+  }
+  let body;
+  if (args["body"] !== void 0 && operation.requestBody) {
+    const contentType = getRequestContentType(operation);
+    headers.set("Content-Type", contentType);
+    try {
+      body = JSON.stringify(args["body"]);
+    } catch {
+      return [{ type: "text", text: "Error: request body could not be serialized to JSON" }];
+    }
+  }
+  let init = {
+    method: operation.method,
+    headers,
+    body
+  };
+  if (config.auth) {
+    try {
+      init = await config.auth.apply(url, init);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return [{ type: "text", text: `Authentication failed: ${msg}` }];
+    }
+  }
+  try {
+    const response = await fetchWithRetry(url.toString(), init, config.fetchOptions);
+    const statusPrefix = `HTTP ${response.status} ${response.statusText}
+
+`;
+    const content = await handleResponse(response);
+    if (content.length > 0 && content[0].type === "text") {
+      content[0] = { type: "text", text: statusPrefix + content[0].text };
+    }
+    return content;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return [{ type: "text", text: `Request failed: ${msg}` }];
+  }
+}
+function validateRequiredParams(operation, args) {
+  const errors = [];
+  for (const param of operation.parameters) {
+    if (param.required && args[param.name] === void 0) {
+      errors.push(`- Missing required ${param.in} parameter: "${param.name}"`);
+    }
+  }
+  if (operation.requestBody?.required && args["body"] === void 0) {
+    errors.push("- Missing required request body");
+  }
+  return errors;
+}
+function getResponseMediaTypes(operation) {
+  const types = /* @__PURE__ */ new Set();
+  for (const resp of Object.values(operation.responses)) {
+    if (resp.content) {
+      for (const mediaType of Object.keys(resp.content)) {
+        types.add(mediaType);
+      }
+    }
+  }
+  return Array.from(types);
+}
+function getRequestContentType(operation) {
+  if (!operation.requestBody?.content) return "application/json";
+  const mediaTypes = Object.keys(operation.requestBody.content);
+  if (mediaTypes.includes("application/json")) return "application/json";
+  return mediaTypes[0] ?? "application/json";
+}
+
+// src/mapper/tools.ts
+import { z as z2 } from "zod";
+
+// src/mapper/schema-converter.ts
+import { z } from "zod";
+function buildToolInputSchema(operation) {
+  const shape = {};
+  for (const param of operation.parameters) {
+    let zodSchema = convertToZod(param.schema);
+    zodSchema = zodSchema.describe(buildParamDescription(param));
+    if (!param.required && !hasDefault(zodSchema)) {
+      zodSchema = zodSchema.optional();
+    }
+    shape[param.name] = zodSchema;
+  }
+  if (operation.requestBody) {
+    const jsonContent = operation.requestBody.content["application/json"] ?? operation.requestBody.content[Object.keys(operation.requestBody.content)[0]];
+    if (jsonContent?.schema) {
+      let bodySchema = convertToZod(jsonContent.schema);
+      const bodyParts = [];
+      if (operation.requestBody.description) bodyParts.push(operation.requestBody.description);
+      if (jsonContent.example !== void 0) {
+        bodyParts.push(`Example: ${truncateExample(jsonContent.example)}`);
+      }
+      if (bodyParts.length > 0) {
+        bodySchema = bodySchema.describe(bodyParts.join(" | "));
+      }
+      if (!operation.requestBody.required) {
+        bodySchema = bodySchema.optional();
+      }
+      shape["body"] = bodySchema;
+    }
+  }
+  return shape;
+}
+function buildParamDescription(param) {
+  const parts = [];
+  if (param.description) parts.push(param.description);
+  if (param.deprecated) parts.push("[DEPRECATED]");
+  if (param.schema.format) parts.push(`format: ${param.schema.format}`);
+  if (param.schema.pattern) parts.push(`pattern: ${param.schema.pattern}`);
+  if (param.example !== void 0) parts.push(`Example: ${truncateExample(param.example)}`);
+  return parts.join(" | ") || param.schema.type || "any";
+}
+function truncateExample(value, maxLen = 100) {
+  const str = typeof value === "string" ? value : JSON.stringify(value);
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function convertToZod(schema) {
+  if ("const" in schema && schema.const !== void 0) {
+    return z.literal(schema.const);
+  }
+  if (schema.enum) {
+    return applyDefault(convertEnum(schema.enum), schema);
+  }
+  if (schema.type === "array") {
+    const items = schema.items ? convertToZod(schema.items) : z.unknown();
+    let arr = z.array(items);
+    if (schema.minItems !== void 0) arr = arr.min(schema.minItems);
+    if (schema.maxItems !== void 0) arr = arr.max(schema.maxItems);
+    return applyDefault(arr, schema);
+  }
+  if (schema.type === "object" || schema.properties) {
+    const objShape = {};
+    if (schema.properties) {
+      const requiredSet = new Set(schema.required ?? []);
+      for (const [key, value] of Object.entries(schema.properties)) {
+        const propSchema = value;
+        let zodProp = convertToZod(propSchema);
+        if (propSchema.description) {
+          zodProp = zodProp.describe(propSchema.description);
+        }
+        if (!requiredSet.has(key) && !hasDefault(zodProp)) {
+          zodProp = zodProp.optional();
+        }
+        objShape[key] = zodProp;
+      }
+    }
+    if (schema.additionalProperties === true || schema.additionalProperties && typeof schema.additionalProperties !== "boolean") {
+      return applyDefault(z.object(objShape).passthrough(), schema);
+    }
+    return applyDefault(z.object(objShape), schema);
+  }
+  if (schema.allOf) {
+    const schemas = schema.allOf.map(convertToZod);
+    if (schemas.length === 1) return schemas[0];
+    let result = schemas[0];
+    for (let i = 1; i < schemas.length; i++) {
+      result = z.intersection(result, schemas[i]);
+    }
+    return result;
+  }
+  if (schema.oneOf) {
+    const schemas = schema.oneOf.map(convertToZod);
+    if (schemas.length === 1) return schemas[0];
+    const [a, b, ...rest] = schemas;
+    return z.union([a, b, ...rest]);
+  }
+  if (schema.anyOf) {
+    const schemas = schema.anyOf.map(convertToZod);
+    if (schemas.length === 1) return schemas[0];
+    const [a, b, ...rest] = schemas;
+    return z.union([a, b, ...rest]);
+  }
+  const base = convertBaseType(schema);
+  return applyDefault(base, schema);
+}
+function convertBaseType(schema) {
+  switch (schema.type) {
+    case "string":
+      return applyStringConstraints(z.string(), schema);
+    case "number":
+    case "integer":
+      return applyNumberConstraints(z.number(), schema);
+    case "boolean":
+      return z.boolean();
+    default:
+      return z.unknown();
+  }
+}
+var NATIVE_STRING_FORMATS = {
+  email: (s) => s.email(),
+  url: (s) => s.url(),
+  uuid: (s) => s.uuid(),
+  datetime: (s) => s.datetime(),
+  "date-time": (s) => s.datetime(),
+  date: (s) => s.date()
+};
+function applyStringConstraints(zStr, schema) {
+  if (schema.minLength !== void 0) zStr = zStr.min(schema.minLength);
+  if (schema.maxLength !== void 0) zStr = zStr.max(schema.maxLength);
+  if (schema.pattern) {
+    try {
+      const re = new RegExp(schema.pattern);
+      zStr = zStr.regex(re);
+    } catch {
+    }
+  }
+  if (schema.format) {
+    const nativeFn = NATIVE_STRING_FORMATS[schema.format];
+    if (nativeFn) {
+      zStr = nativeFn(zStr);
+    }
+  }
+  return zStr;
+}
+function applyNumberConstraints(zNum, schema) {
+  if (schema.type === "integer") zNum = zNum.int();
+  if (schema.minimum !== void 0) {
+    if (typeof schema.exclusiveMinimum === "boolean" && schema.exclusiveMinimum) {
+      zNum = zNum.gt(schema.minimum);
+    } else {
+      zNum = zNum.min(schema.minimum);
+    }
+  }
+  if (schema.maximum !== void 0) {
+    if (typeof schema.exclusiveMaximum === "boolean" && schema.exclusiveMaximum) {
+      zNum = zNum.lt(schema.maximum);
+    } else {
+      zNum = zNum.max(schema.maximum);
+    }
+  }
+  if (typeof schema.exclusiveMinimum === "number") {
+    zNum = zNum.gt(schema.exclusiveMinimum);
+  }
+  if (typeof schema.exclusiveMaximum === "number") {
+    zNum = zNum.lt(schema.exclusiveMaximum);
+  }
+  return zNum;
+}
+function applyDefault(zSchema, schema) {
+  if (schema.default !== void 0) {
+    return zSchema.default(schema.default);
+  }
+  return zSchema;
+}
+function hasDefault(schema) {
+  return schema instanceof z.ZodDefault;
+}
+function convertEnum(values) {
+  const allStrings = values.every((v) => typeof v === "string");
+  if (allStrings && values.length >= 2) {
+    const [first, second, ...rest] = values;
+    return z.enum([first, second, ...rest]);
+  }
+  if (allStrings && values.length === 1) {
+    return z.literal(values[0]);
+  }
+  if (values.length === 1) {
+    return z.literal(values[0]);
+  }
+  const schemas = values.map((v) => z.literal(v));
+  if (schemas.length >= 2) {
+    const [a, b, ...rest] = schemas;
+    return z.union([a, b, ...rest]);
+  }
+  return z.unknown();
+}
+
+// src/utils/naming.ts
+function sanitizeToolName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 64);
+}
+function truncateDescription(text, maxLength = 200) {
+  if (!text) return "";
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+
+// src/mapper/tools.ts
+function registerTools(server, spec, httpConfig) {
+  for (const operation of spec.operations) {
+    const toolName = sanitizeToolName(operation.operationId);
+    const rawDescription = (operation.summary ?? operation.description ?? "").trim().replace(/\s+/g, " ");
+    const prefix = operation.deprecated ? "[DEPRECATED] " : "";
+    const description = truncateDescription(`${prefix}${rawDescription}`) || `${operation.method} ${operation.path}`;
+    const shape = buildToolInputSchema(operation);
+    server.tool(
+      toolName,
+      description,
+      shape,
+      async (args) => {
+        const content = await executeOperation(operation, args, httpConfig);
+        return { content };
+      }
+    );
+  }
+  if (spec.servers.length > 0) {
+    registerSetEnvironmentTool(server, spec, httpConfig);
+  }
+}
+function registerSetEnvironmentTool(server, spec, httpConfig) {
+  const shape = {
+    server_index: z2.number().int().min(0).optional().describe("Index of the server to use (0-based)"),
+    server_url: z2.string().optional().describe("Direct URL override (takes precedence over server_index)"),
+    variables: z2.record(z2.string()).optional().describe('Server variable overrides (e.g. {"environment": "staging"})')
+  };
+  server.tool(
+    "set_environment",
+    "Switch the active API server/environment. Lists available servers when called without arguments.",
+    shape,
+    async (args) => {
+      const lines = [];
+      if (args.server_url) {
+        httpConfig.baseUrl = args.server_url.replace(/\/$/, "");
+        lines.push(`Active server set to: ${httpConfig.baseUrl}`);
+      } else if (args.server_index !== void 0) {
+        const server2 = spec.servers[args.server_index];
+        if (!server2) {
+          return {
+            content: [{ type: "text", text: `Invalid server_index ${args.server_index}. Available: 0-${spec.servers.length - 1}` }]
+          };
+        }
+        httpConfig.baseUrl = resolveServerUrl(server2, args.variables);
+        lines.push(`Active server set to: ${httpConfig.baseUrl}`);
+        if (server2.description) lines.push(`  (${server2.description})`);
+      } else if (args.variables) {
+        const current = spec.servers.find((s) => {
+          try {
+            return resolveServerUrl(s) === httpConfig.baseUrl;
+          } catch {
+            return false;
+          }
+        });
+        if (current) {
+          httpConfig.baseUrl = resolveServerUrl(current, args.variables);
+          lines.push(`Active server re-resolved to: ${httpConfig.baseUrl}`);
+        } else {
+          return {
+            content: [{ type: "text", text: "Cannot apply variables: current baseUrl does not match any known server. Use server_index or server_url instead." }]
+          };
+        }
+      } else {
+        lines.push(`Current active server: ${httpConfig.baseUrl}`);
+      }
+      lines.push("", "Available servers:");
+      for (let i = 0; i < spec.servers.length; i++) {
+        const s = spec.servers[i];
+        const resolved = tryResolveUrl(s);
+        const active = resolved === httpConfig.baseUrl ? " [active]" : "";
+        const desc = s.description ? ` \u2014 ${s.description}` : "";
+        lines.push(`  [${i}] ${s.url}${desc}${active}`);
+        if (s.variables) {
+          for (const [name, v] of Object.entries(s.variables)) {
+            const enumStr = v.enum ? ` enum=[${v.enum.join(",")}]` : "";
+            lines.push(`       {${name}}: default="${v.default}"${enumStr}${v.description ? ` \u2014 ${v.description}` : ""}`);
+          }
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+function tryResolveUrl(server) {
+  try {
+    return resolveServerUrl(server);
+  } catch {
+    return null;
+  }
+}
+
+// src/mapper/resources.ts
+function registerResources(server, spec) {
+  server.resource(
+    "openapi-spec",
+    "openapi://spec",
+    {
+      description: `Full OpenAPI spec for ${spec.title} v${spec.version}`,
+      mimeType: "application/json"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "openapi://spec",
+          mimeType: "application/json",
+          text: JSON.stringify(spec.raw, null, 2)
+        }
+      ]
+    })
+  );
+  for (const [name, schema] of Object.entries(spec.schemas)) {
+    const safeName = encodeURIComponent(name);
+    const uri = `openapi://schemas/${safeName}`;
+    server.resource(
+      `schema-${safeName}`,
+      uri,
+      {
+        description: (schema.description ?? `Schema: ${name}`).slice(0, 200),
+        mimeType: "application/json"
+      },
+      async () => ({
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(schema, null, 2)
+          }
+        ]
+      })
+    );
+  }
+  if (spec.servers.length > 0) {
+    server.resource(
+      "openapi-servers",
+      "openapi://servers",
+      {
+        description: `Available API servers/environments for ${spec.title}`,
+        mimeType: "application/json"
+      },
+      async () => ({
+        contents: [
+          {
+            uri: "openapi://servers",
+            mimeType: "application/json",
+            text: JSON.stringify(spec.servers, null, 2)
+          }
+        ]
+      })
+    );
+  }
+}
+
+// src/mapper/prompts.ts
+import { z as z3 } from "zod";
+function registerPrompts(server, spec, httpConfig) {
+  server.prompt(
+    "describe-api",
+    "Get an overview of this API including endpoints, authentication, and capabilities",
+    {},
+    async () => {
+      const endpoints = spec.operations.map((op) => {
+        const prefix = op.deprecated ? "[DEPRECATED] " : "";
+        return `  ${prefix}${op.method.padEnd(7)} ${op.path} - ${op.summary ?? op.operationId}`;
+      });
+      const authSchemes = Object.entries(spec.securitySchemes).map(([name, scheme]) => `  ${name}: ${scheme.type}${"scheme" in scheme ? ` (${scheme.scheme})` : ""}`);
+      const text = [
+        `# ${spec.title} v${spec.version}`,
+        "",
+        spec.description ?? "",
+        "",
+        formatServersSection(spec, httpConfig),
+        "",
+        formatExternalDocsSection(spec),
+        "",
+        `## Endpoints (${spec.operations.length})`,
+        ...endpoints,
+        "",
+        `## Authentication`,
+        authSchemes.length > 0 ? authSchemes.join("\n") : "  None required",
+        "",
+        `## Schemas`,
+        Object.keys(spec.schemas).map((name) => `  - ${name}`).join("\n") || "  None defined",
+        "",
+        formatTagsSection(spec)
+      ].filter((line) => line !== void 0 && line !== "").join("\n");
+      return {
+        messages: [
+          {
+            role: "user",
+            content: { type: "text", text }
+          }
+        ]
+      };
+    }
+  );
+  server.prompt(
+    "explore-endpoint",
+    "Get detailed information about a specific API endpoint",
+    { operationId: z3.string().describe("The operationId of the endpoint to explore") },
+    async ({ operationId }) => {
+      const operation = spec.operations.find((op) => op.operationId === operationId);
+      if (!operation) {
+        const available = spec.operations.map((op) => op.operationId).join(", ");
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Operation "${operationId}" not found. Available operations: ${available}`
+              }
+            }
+          ]
+        };
+      }
+      const text = buildEndpointPrompt(operation, spec.tags);
+      return {
+        messages: [
+          {
+            role: "user",
+            content: { type: "text", text }
+          }
+        ]
+      };
+    }
+  );
+}
+function formatServersSection(spec, httpConfig) {
+  if (spec.servers.length === 0) return "## Servers\n  (not specified)";
+  const lines = ["## Servers"];
+  for (let i = 0; i < spec.servers.length; i++) {
+    const s = spec.servers[i];
+    let resolved = null;
+    try {
+      resolved = resolveServerUrl(s);
+    } catch {
+    }
+    const active = resolved === httpConfig.baseUrl ? " [active]" : "";
+    const desc = s.description ? ` \u2014 ${s.description}` : "";
+    lines.push(`  [${i}]${active} ${s.url}${desc}`);
+    if (s.variables) {
+      for (const [name, v] of Object.entries(s.variables)) {
+        const enumStr = v.enum ? `=[${v.enum.join(",")}]` : "";
+        lines.push(`       {${name}}: default="${v.default}"${enumStr}${v.description ? ` \u2014 ${v.description}` : ""}`);
+      }
+    }
+  }
+  if (spec.servers.length > 1) {
+    lines.push("", "  Use the `set_environment` tool to switch servers.");
+  }
+  return lines.join("\n");
+}
+function formatTagsSection(spec) {
+  if (spec.tags.length === 0) return "";
+  const lines = ["## Tags"];
+  for (const tag of spec.tags) {
+    let line = `  - **${tag.name}**`;
+    if (tag.description) line += `: ${tag.description}`;
+    if (tag.externalDocs) line += ` (docs: ${tag.externalDocs.url})`;
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+function formatExternalDocsSection(spec) {
+  if (!spec.externalDocs) return "";
+  const desc = spec.externalDocs.description ? `${spec.externalDocs.description}: ` : "";
+  return `## External Documentation
+  ${desc}${spec.externalDocs.url}`;
+}
+function buildEndpointPrompt(operation, globalTags) {
+  const deprecatedTag = operation.deprecated ? " [DEPRECATED]" : "";
+  const params = operation.parameters.map((p) => {
+    const parts = [
+      `  - ${p.name} (${p.in}, ${p.required ? "required" : "optional"})`
+    ];
+    if (p.deprecated) parts[0] += " [DEPRECATED]";
+    parts[0] += `: ${p.description ?? p.schema.type ?? "any"}`;
+    if (p.schema.format) parts[0] += ` (format: ${p.schema.format})`;
+    if (p.example !== void 0) parts[0] += ` \u2014 example: ${formatExample(p.example)}`;
+    return parts[0];
+  });
+  const responses = formatResponses(operation.responses);
+  const links = formatLinks(operation.responses);
+  const sections = [
+    `# ${operation.method} ${operation.path}${deprecatedTag}`,
+    `operationId: ${operation.operationId}`,
+    "",
+    operation.summary ? `**Summary**: ${operation.summary}` : "",
+    operation.description ? `**Description**: ${operation.description}` : "",
+    "",
+    `## Parameters`,
+    params.length > 0 ? params.join("\n") : "  None",
+    "",
+    formatRequestBody(operation),
+    "",
+    `## Responses`,
+    ...responses,
+    ""
+  ];
+  if (links.length > 0) {
+    sections.push(`## Links`, ...links, "");
+  }
+  sections.push(
+    `## Security`,
+    operation.security.length > 0 ? operation.security.map((s) => `  ${Object.keys(s).join(", ")}`).join("\n") : "  None",
+    ""
+  );
+  if (operation.tags.length > 0) {
+    const tagLines = ["## Tags"];
+    for (const tagName of operation.tags) {
+      const globalTag = globalTags.find((t) => t.name === tagName);
+      let line = `  - **${tagName}**`;
+      if (globalTag?.description) line += `: ${globalTag.description}`;
+      if (globalTag?.externalDocs) line += ` (docs: ${globalTag.externalDocs.url})`;
+      tagLines.push(line);
+    }
+    sections.push(tagLines.join("\n"));
+  }
+  if (operation.externalDocs) {
+    const desc = operation.externalDocs.description ? `${operation.externalDocs.description}: ` : "";
+    sections.push("", `## External Documentation`, `  ${desc}${operation.externalDocs.url}`);
+  }
+  return sections.filter((line) => line !== void 0).join("\n");
+}
+function formatRequestBody(operation) {
+  if (!operation.requestBody) return "";
+  const lines = [
+    `## Request Body ${operation.requestBody.required ? "(required)" : "(optional)"}`,
+    operation.requestBody.description ?? "",
+    "```json",
+    safeStringify(
+      Object.values(operation.requestBody.content)[0]?.schema ?? {},
+      null,
+      2
+    ),
+    "```"
+  ];
+  const jsonContent = operation.requestBody.content["application/json"] ?? Object.values(operation.requestBody.content)[0];
+  if (jsonContent?.example !== void 0) {
+    lines.push("", "**Example:**", "```json", safeStringify(jsonContent.example, null, 2), "```");
+  }
+  return lines.join("\n");
+}
+function formatResponses(responses) {
+  const lines = [];
+  for (const [code, resp] of Object.entries(responses)) {
+    lines.push(`  ${code}: ${resp.description || "(no description)"}`);
+    if (resp.schema) {
+      lines.push("  ```json", `  ${safeStringify(resp.schema, null, 2).split("\n").join("\n  ")}`, "  ```");
+    }
+    if (resp.example !== void 0) {
+      lines.push(`  Example:`);
+      lines.push("  ```json", `  ${safeStringify(resp.example, null, 2).split("\n").join("\n  ")}`, "  ```");
+    }
+  }
+  return lines;
+}
+function formatLinks(responses) {
+  const lines = [];
+  for (const [code, resp] of Object.entries(responses)) {
+    if (!resp.links) continue;
+    for (const [, link] of Object.entries(resp.links)) {
+      const target = link.operationId ?? link.operationRef ?? "(unknown)";
+      const params = link.parameters ? Object.entries(link.parameters).map(([k, v]) => `${k}=${v}`).join(", ") : "";
+      const desc = link.description ? ` \u2014 ${link.description}` : "";
+      lines.push(`  After ${code} response, call \`${target}\`${params ? ` with {${params}}` : ""}${desc}`);
+    }
+  }
+  return lines;
+}
+function formatExample(value) {
+  if (typeof value === "string") return value;
+  return safeStringify(value);
+}
+function safeStringify(value, _replacer, indent) {
+  try {
+    return JSON.stringify(value, null, indent);
+  } catch {
+    return "(circular or non-serializable)";
+  }
+}
+
+// src/server.ts
+async function createOpenApiMcp(options) {
+  const doc = await loadSpec(options.source);
+  const spec = await resolveSpec(doc);
+  const serverName = options.name ?? spec.title ?? "dynamic-openapi-mcp";
+  const serverVersion = options.version ?? spec.version ?? "1.0.0";
+  const server = new McpServer({
+    name: serverName,
+    version: serverVersion
+  });
+  const auth = resolveAuth(options.auth, spec.securitySchemes);
+  const baseUrl = resolveBaseUrl(spec, options.baseUrl, options.serverIndex);
+  const httpConfig = {
+    baseUrl,
+    auth,
+    defaultHeaders: options.headers,
+    fetchOptions: options.fetchOptions
+  };
+  registerTools(server, spec, httpConfig);
+  registerResources(server, spec);
+  registerPrompts(server, spec, httpConfig);
+  return {
+    server,
+    spec,
+    async serve() {
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+    }
+  };
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    if ((arg === "-s" || arg === "--source") && next) {
+      args.source = next;
+      i++;
+    } else if ((arg === "-b" || arg === "--base-url") && next) {
+      args.baseUrl = next;
+      i++;
+    } else if (arg === "--server-index" && next) {
+      const parsed = parseInt(next, 10);
+      if (isNaN(parsed) || parsed < 0) {
+        console.error(`Error: --server-index must be a non-negative integer, got "${next}"`);
+        process.exit(1);
+      }
+      args.serverIndex = parsed;
+      i++;
+    } else if (arg === "-h" || arg === "--help") {
+      printHelp();
+      process.exit(0);
+    } else if (!arg.startsWith("-") && !args.source) {
+      args.source = arg;
+    }
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`
+dynamic-openapi-mcp - Transform OpenAPI specs into MCP servers
+
+Usage:
+  dynamic-openapi-mcp [options] [source]
+
+Options:
+  -s, --source <url|file>   OpenAPI spec URL or file path
+  -b, --base-url <url>      Override the base URL from the spec
+  --server-index <n>         Use the Nth server from the spec (0-based, default: 0)
+  -h, --help                Show this help message
+
+Environment Variables:
+  OPENAPI_SOURCE            OpenAPI spec URL or file path
+  OPENAPI_BASE_URL          Override base URL
+  OPENAPI_SERVER_INDEX      Server index (0-based)
+  OPENAPI_AUTH_TOKEN        Bearer token for API authentication
+  OPENAPI_API_KEY           API key for authentication
+
+Examples:
+  dynamic-openapi-mcp -s https://petstore3.swagger.io/api/v3/openapi.json
+  dynamic-openapi-mcp ./spec.yaml
+  dynamic-openapi-mcp --server-index 1 ./spec.yaml
+  OPENAPI_SOURCE=./spec.yaml OPENAPI_AUTH_TOKEN=sk-123 dynamic-openapi-mcp
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  const source = args.source ?? process.env["OPENAPI_SOURCE"] ?? process.env["OPENAPI_SOURCE_FILE"];
+  if (!source) {
+    console.error("Error: No OpenAPI source specified.");
+    console.error("Use -s <url|file> or set OPENAPI_SOURCE environment variable.");
+    console.error("Run dynamic-openapi-mcp --help for usage information.");
+    process.exit(1);
+  }
+  const baseUrl = args.baseUrl ?? process.env["OPENAPI_BASE_URL"];
+  let serverIndex = args.serverIndex;
+  if (serverIndex === void 0 && process.env["OPENAPI_SERVER_INDEX"]) {
+    const parsed = parseInt(process.env["OPENAPI_SERVER_INDEX"], 10);
+    if (!isNaN(parsed) && parsed >= 0) {
+      serverIndex = parsed;
+    }
+  }
+  try {
+    const mcp = await createOpenApiMcp({
+      source,
+      baseUrl,
+      serverIndex
+    });
+    const opCount = mcp.spec.operations.length;
+    const schemaCount = Object.keys(mcp.spec.schemas).length;
+    process.stderr.write(
+      `dynamic-openapi-mcp: loaded "${mcp.spec.title}" v${mcp.spec.version} \u2014 ${opCount} tools, ${schemaCount} schemas
+`
+    );
+    await mcp.serve();
+  } catch (error) {
+    if (error instanceof Error) {
+      process.stderr.write(`dynamic-openapi-mcp: ${error.message}
+`);
+      if (error.stack) {
+        process.stderr.write(`${error.stack}
+`);
+      }
+    } else {
+      process.stderr.write(`dynamic-openapi-mcp: ${String(error)}
+`);
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map