api2mcp 0.0.1 → 0.2.0

package/dist/index.js

@@ -0,0 +1,1049 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Api2McpError: () => Api2McpError,
+  ConfigurationError: () => ConfigurationError,
+  HttpError: () => HttpError,
+  OpenApiParseError: () => OpenApiParseError,
+  ToolExecutionError: () => ToolExecutionError,
+  ToolManager: () => ToolManager,
+  convertSchema: () => convertSchema,
+  createRefResolver: () => createRefResolver,
+  createServer: () => createServer,
+  executeRequest: () => executeRequest,
+  formatResponse: () => formatResponse,
+  generateTool: () => generateTool,
+  generateTools: () => generateTools,
+  getBaseUrl: () => getBaseUrl,
+  loadConfig: () => loadConfig,
+  logger: () => logger,
+  parseOpenApi: () => parseOpenApi,
+  startServer: () => startServer
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/config/loader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+
+// src/utils/error.ts
+var Api2McpError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "Api2McpError";
+  }
+};
+var ConfigurationError = class extends Api2McpError {
+  constructor(message, cause) {
+    super(message, "CONFIGURATION_ERROR", cause);
+    this.name = "ConfigurationError";
+  }
+};
+var OpenApiParseError = class extends Api2McpError {
+  constructor(message, cause) {
+    super(message, "OPENAPI_PARSE_ERROR", cause);
+    this.name = "OpenApiParseError";
+  }
+};
+var ToolExecutionError = class extends Api2McpError {
+  constructor(message, toolName, cause) {
+    super(message, "TOOL_EXECUTION_ERROR", cause);
+    this.toolName = toolName;
+    this.name = "ToolExecutionError";
+  }
+};
+var HttpError = class extends Api2McpError {
+  constructor(message, statusCode, responseBody, cause) {
+    super(message, "HTTP_ERROR", cause);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "HttpError";
+  }
+};
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = "info";
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+function formatMessage(level, message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `[${timestamp}] [${level.toUpperCase()}] ${message}`;
+}
+var logger = {
+  debug(message, ...args) {
+    if (shouldLog("debug")) {
+      console.error(formatMessage("debug", message), ...args);
+    }
+  },
+  info(message, ...args) {
+    if (shouldLog("info")) {
+      console.error(formatMessage("info", message), ...args);
+    }
+  },
+  warn(message, ...args) {
+    if (shouldLog("warn")) {
+      console.error(formatMessage("warn", message), ...args);
+    }
+  },
+  error(message, ...args) {
+    if (shouldLog("error")) {
+      console.error(formatMessage("error", message), ...args);
+    }
+  },
+  setLevel(level) {
+    currentLevel = level;
+  }
+};
+
+// src/config/loader.ts
+var DEFAULT_TIMEOUT = 3e4;
+var CONFIG_FILE_NAMES = ["api2mcp.json", "api2mcp.config.json", ".api2mcp.json"];
+function parseHeaders(headersStr) {
+  if (!headersStr) return void 0;
+  try {
+    const parsed = JSON.parse(headersStr);
+    if (typeof parsed === "object" && parsed !== null) {
+      return parsed;
+    }
+    throw new Error("Headers must be a JSON object");
+  } catch (error) {
+    throw new ConfigurationError(
+      `Invalid headers JSON: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function loadFromEnv(env) {
+  const config = {};
+  if (env.OPENAPI_URL) {
+    config.openapiUrl = env.OPENAPI_URL;
+  }
+  if (env.API_BASE_URL) {
+    config.baseUrl = env.API_BASE_URL;
+  }
+  if (env.API_TIMEOUT) {
+    const timeout = parseInt(env.API_TIMEOUT, 10);
+    if (!Number.isNaN(timeout) && timeout > 0) {
+      config.timeout = timeout;
+    }
+  }
+  if (env.API_HEADERS) {
+    config.headers = parseHeaders(env.API_HEADERS);
+  }
+  if (env.DEBUG) {
+    config.debug = env.DEBUG === "true" || env.DEBUG === "1";
+  }
+  return config;
+}
+function loadFromFile(workingDir = process.cwd()) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = (0, import_node_path.resolve)(workingDir, fileName);
+    if ((0, import_node_fs.existsSync)(filePath)) {
+      try {
+        const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+        const parsed = JSON.parse(content);
+        logger.info(`Loaded configuration from ${filePath}`);
+        return {
+          openapiUrl: parsed.openapiUrl,
+          baseUrl: parsed.baseUrl,
+          timeout: parsed.timeout,
+          headers: parsed.headers,
+          toolPrefix: parsed.toolPrefix,
+          debug: parsed.debug
+        };
+      } catch (error) {
+        throw new ConfigurationError(
+          `Failed to load config file ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  }
+  return null;
+}
+function loadFromCli(args) {
+  const config = {};
+  if (args.url) {
+    config.openapiUrl = args.url;
+  }
+  if (args.baseUrl) {
+    config.baseUrl = args.baseUrl;
+  }
+  if (args.timeout) {
+    config.timeout = args.timeout;
+  }
+  if (args.headers) {
+    config.headers = parseHeaders(args.headers);
+  }
+  if (args.prefix) {
+    config.toolPrefix = args.prefix;
+  }
+  if (args.debug !== void 0) {
+    config.debug = args.debug;
+  }
+  return config;
+}
+function mergeConfigs(...configs) {
+  const merged = {
+    openapiUrl: "",
+    debug: false
+  };
+  for (const config of configs) {
+    if (config.openapiUrl !== void 0) merged.openapiUrl = config.openapiUrl;
+    if (config.baseUrl !== void 0) merged.baseUrl = config.baseUrl;
+    if (config.timeout !== void 0) merged.timeout = config.timeout;
+    if (config.headers !== void 0) merged.headers = config.headers;
+    if (config.toolPrefix !== void 0) merged.toolPrefix = config.toolPrefix;
+    if (config.debug !== void 0) merged.debug = config.debug;
+  }
+  if (merged.timeout === void 0) {
+    merged.timeout = DEFAULT_TIMEOUT;
+  }
+  return merged;
+}
+function loadConfig(cliArgs = {}, env = process.env) {
+  const fileConfig = loadFromFile() ?? {};
+  const envConfig = loadFromEnv(env);
+  const cliConfig = loadFromCli(cliArgs);
+  const config = mergeConfigs(cliConfig, envConfig, fileConfig);
+  if (!config.openapiUrl) {
+    throw new ConfigurationError(
+      "OpenAPI URL is required. Provide it via --url, OPENAPI_URL env, or config file."
+    );
+  }
+  if (config.debug) {
+    logger.setLevel("debug");
+  }
+  logger.debug("Loaded configuration:", {
+    openapiUrl: config.openapiUrl,
+    baseUrl: config.baseUrl,
+    timeout: config.timeout,
+    toolPrefix: config.toolPrefix,
+    debug: config.debug
+  });
+  return config;
+}
+
+// src/converter/schema-converter.ts
+var import_zod = require("zod");
+var defaultRefResolver = () => void 0;
+function convertSchema(schema, refResolver = defaultRefResolver) {
+  if (!schema) {
+    return import_zod.z.unknown();
+  }
+  if (schema.$ref) {
+    const resolved = refResolver(schema.$ref);
+    if (resolved) {
+      return convertSchema(resolved, refResolver);
+    }
+    logger.warn(`Unresolved $ref: ${schema.$ref}`);
+    return import_zod.z.unknown();
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    const schemas = schema.allOf.map((s) => convertSchema(s, refResolver));
+    if (schemas.length === 1) {
+      return schemas[0];
+    }
+    return schemas.reduce((acc, s) => acc.and(s));
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    const schemas = schema.oneOf.map((s) => convertSchema(s, refResolver));
+    return import_zod.z.union([schemas[0], schemas[1] || schemas[0], ...schemas.slice(2)]);
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    const schemas = schema.anyOf.map((s) => convertSchema(s, refResolver));
+    if (schemas.length === 1) {
+      return schemas[0].optional();
+    }
+    return import_zod.z.union([schemas[0], schemas[1] || schemas[0], ...schemas.slice(2)]);
+  }
+  const nullable = schema.nullable === true;
+  let zodSchema;
+  switch (schema.type) {
+    case "string":
+      zodSchema = convertStringSchema(schema);
+      break;
+    case "number":
+    case "integer":
+      zodSchema = convertNumberSchema(schema);
+      break;
+    case "boolean":
+      zodSchema = import_zod.z.boolean();
+      break;
+    case "array":
+      zodSchema = convertArraySchema(schema, refResolver);
+      break;
+    case "object":
+      zodSchema = convertObjectSchema(schema, refResolver);
+      break;
+    default:
+      if (schema.properties) {
+        zodSchema = convertObjectSchema(schema, refResolver);
+      } else {
+        zodSchema = import_zod.z.unknown();
+      }
+  }
+  if (nullable) {
+    zodSchema = zodSchema.nullable();
+  }
+  if (schema.default !== void 0) {
+    zodSchema = zodSchema.default(schema.default);
+  }
+  if (schema.description) {
+    zodSchema = zodSchema.describe(schema.description);
+  }
+  return zodSchema;
+}
+function convertStringSchema(schema) {
+  let zodSchema = import_zod.z.string();
+  if (schema.minLength !== void 0) {
+    zodSchema = zodSchema.min(schema.minLength);
+  }
+  if (schema.maxLength !== void 0) {
+    zodSchema = zodSchema.max(schema.maxLength);
+  }
+  if (schema.pattern) {
+    zodSchema = zodSchema.regex(new RegExp(schema.pattern));
+  }
+  if (schema.format) {
+    switch (schema.format) {
+      case "email":
+        zodSchema = zodSchema.email();
+        break;
+      case "uri":
+      case "url":
+        zodSchema = zodSchema.url();
+        break;
+      case "uuid":
+        zodSchema = zodSchema.uuid();
+        break;
+      case "date":
+        zodSchema = zodSchema.date();
+        break;
+      case "date-time":
+        zodSchema = zodSchema.datetime();
+        break;
+    }
+  }
+  if (schema.enum) {
+    const enumValues = schema.enum;
+    zodSchema = import_zod.z.enum(enumValues);
+  }
+  return zodSchema;
+}
+function convertNumberSchema(schema) {
+  let zodSchema = schema.type === "integer" ? import_zod.z.number().int() : import_zod.z.number();
+  if (schema.minimum !== void 0) {
+    zodSchema = zodSchema.min(schema.minimum);
+  }
+  if (schema.maximum !== void 0) {
+    zodSchema = zodSchema.max(schema.maximum);
+  }
+  if (schema.exclusiveMinimum === true && schema.minimum !== void 0) {
+    zodSchema = zodSchema.min(schema.minimum + (schema.type === "integer" ? 1 : Number.MIN_VALUE));
+  } else if (typeof schema.exclusiveMinimum === "number") {
+    zodSchema = zodSchema.min(
+      schema.exclusiveMinimum + (schema.type === "integer" ? 1 : Number.MIN_VALUE)
+    );
+  }
+  if (schema.exclusiveMaximum === true && schema.maximum !== void 0) {
+    zodSchema = zodSchema.max(schema.maximum - (schema.type === "integer" ? 1 : Number.MIN_VALUE));
+  } else if (typeof schema.exclusiveMaximum === "number") {
+    zodSchema = zodSchema.max(
+      schema.exclusiveMaximum - (schema.type === "integer" ? 1 : Number.MIN_VALUE)
+    );
+  }
+  if (schema.enum) {
+    const enumValues = schema.enum;
+    zodSchema = import_zod.z.enum(enumValues.map(String));
+  }
+  return zodSchema;
+}
+function convertArraySchema(schema, refResolver) {
+  const itemSchema = schema.items ? convertSchema(schema.items, refResolver) : import_zod.z.unknown();
+  let zodSchema = import_zod.z.array(itemSchema);
+  if (schema.minItems !== void 0) {
+    zodSchema = zodSchema.min(schema.minItems);
+  }
+  if (schema.maxItems !== void 0) {
+    zodSchema = zodSchema.max(schema.maxItems);
+  }
+  return zodSchema;
+}
+function convertObjectSchema(schema, refResolver) {
+  const properties = schema.properties || {};
+  const required = new Set(schema.required || []);
+  if (Object.keys(properties).length === 0) {
+    if (schema.additionalProperties) {
+      if (typeof schema.additionalProperties === "boolean") {
+        return import_zod.z.record(import_zod.z.unknown());
+      }
+      return import_zod.z.record(convertSchema(schema.additionalProperties, refResolver));
+    }
+    return import_zod.z.record(import_zod.z.unknown());
+  }
+  const zodProperties = {};
+  for (const [name, prop] of Object.entries(properties)) {
+    let propSchema = convertSchema(prop, refResolver);
+    if (!required.has(name)) {
+      propSchema = propSchema.optional();
+    }
+    zodProperties[name] = propSchema;
+  }
+  let zodSchema = import_zod.z.object(zodProperties);
+  if (schema.additionalProperties) {
+    if (typeof schema.additionalProperties === "boolean") {
+      zodSchema = import_zod.z.object(zodProperties).passthrough();
+    } else {
+      logger.debug("Typed additionalProperties is not fully supported, using passthrough");
+      zodSchema = import_zod.z.object(zodProperties).passthrough();
+    }
+  } else {
+    zodSchema = import_zod.z.object(zodProperties).strict();
+  }
+  return zodSchema;
+}
+function createRefResolver(components) {
+  return (ref) => {
+    const match = ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (match && components) {
+      return components[match[1]];
+    }
+    return void 0;
+  };
+}
+
+// src/converter/tool-generator.ts
+var import_zod2 = require("zod");
+function generateToolName(operation, prefix) {
+  if (operation.operationId) {
+    const name2 = sanitizeToolName(operation.operationId);
+    return prefix ? `${prefix}_${name2}` : name2;
+  }
+  const pathParts = operation.path.split("/").filter(Boolean).map((part) => part.replace(/[{}]/g, ""));
+  const name = sanitizeToolName(`${operation.method.toLowerCase()}_${pathParts.join("_")}`);
+  return prefix ? `${prefix}_${name}` : name;
+}
+function sanitizeToolName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toLowerCase();
+}
+function generateToolDescription(operation) {
+  const parts = [];
+  if (operation.summary) {
+    parts.push(operation.summary);
+  }
+  if (operation.description) {
+    parts.push(operation.description);
+  }
+  if (operation.deprecated) {
+    parts.push("[DEPRECATED]");
+  }
+  parts.push(`
+
+HTTP ${operation.method} ${operation.path}`);
+  if (operation.tags && operation.tags.length > 0) {
+    parts.push(`
+Tags: ${operation.tags.join(", ")}`);
+  }
+  return parts.join("\n");
+}
+function buildParametersSchema(operation, refResolver) {
+  const shape = {};
+  if (operation.parameters) {
+    for (const param of operation.parameters) {
+      const paramName = param.name;
+      let paramSchema = convertSchema(param.schema, refResolver);
+      if (param.description) {
+        paramSchema = paramSchema.describe(param.description);
+      }
+      if (!param.required) {
+        paramSchema = paramSchema.optional();
+      }
+      const key = paramName;
+      shape[key] = paramSchema;
+    }
+  }
+  if (operation.requestBody) {
+    const jsonContent = operation.requestBody.content["application/json"];
+    if (jsonContent?.schema) {
+      const bodySchema = convertSchema(jsonContent.schema, refResolver);
+      if (operation.requestBody.description) {
+        shape.body = bodySchema.describe(operation.requestBody.description);
+      } else {
+        shape.body = bodySchema.describe("Request body");
+      }
+      if (!operation.requestBody.required) {
+        shape.body = shape.body.optional();
+      }
+    } else {
+      const contentTypes = Object.keys(operation.requestBody.content);
+      if (contentTypes.length > 0) {
+        const firstContent = operation.requestBody.content[contentTypes[0]];
+        if (firstContent?.schema) {
+          const bodySchema = convertSchema(firstContent.schema, refResolver);
+          shape.body = bodySchema.describe(`Request body (${contentTypes[0]})`);
+          if (!operation.requestBody.required) {
+            shape.body = shape.body.optional();
+          }
+        }
+      }
+    }
+  }
+  return shape;
+}
+function generateTool(operation, components, toolPrefix) {
+  const refResolver = createRefResolver(components);
+  const name = generateToolName(operation, toolPrefix);
+  const description = generateToolDescription(operation);
+  const parametersShape = buildParametersSchema(operation, refResolver);
+  const inputSchema = import_zod2.z.object(parametersShape);
+  logger.debug(`Generated tool: ${name}`);
+  return {
+    name,
+    description,
+    inputSchema,
+    operation
+  };
+}
+function generateTools(operations, components, toolPrefix) {
+  const tools = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    const tool = generateTool(operation, components, toolPrefix);
+    if (usedNames.has(tool.name)) {
+      let counter = 1;
+      let newName = `${tool.name}_${counter}`;
+      while (usedNames.has(newName)) {
+        counter++;
+        newName = `${tool.name}_${counter}`;
+      }
+      logger.warn(`Tool name conflict: ${tool.name} renamed to ${newName}`);
+      tool.name = newName;
+    }
+    usedNames.add(tool.name);
+    tools.push(tool);
+  }
+  logger.info(`Generated ${tools.length} tools`);
+  return tools;
+}
+
+// src/executor/request-builder.ts
+function groupParametersByLocation(parameters) {
+  const groups = {
+    path: [],
+    query: [],
+    header: [],
+    cookie: []
+  };
+  if (parameters) {
+    for (const param of parameters) {
+      groups[param.in].push(param);
+    }
+  }
+  return groups;
+}
+function buildRequest(operation, input, defaultHeaders = {}) {
+  const groupedParams = groupParametersByLocation(operation.parameters);
+  let path = operation.path;
+  for (const param of groupedParams.path) {
+    const value = input[param.name];
+    if (value !== void 0) {
+      path = path.replace(`{${param.name}}`, String(value));
+    } else if (param.required) {
+      throw new Error(`Missing required path parameter: ${param.name}`);
+    }
+  }
+  const query = {};
+  for (const param of groupedParams.query) {
+    const value = input[param.name];
+    if (value !== void 0) {
+      if (Array.isArray(value)) {
+        query[param.name] = value.map(String);
+      } else {
+        query[param.name] = String(value);
+      }
+    } else if (param.required) {
+      throw new Error(`Missing required query parameter: ${param.name}`);
+    }
+  }
+  const headers = { ...defaultHeaders };
+  for (const param of groupedParams.header) {
+    const value = input[param.name];
+    if (value !== void 0) {
+      headers[param.name] = String(value);
+    } else if (param.required) {
+      throw new Error(`Missing required header parameter: ${param.name}`);
+    }
+  }
+  const body = input.body;
+  if (body !== void 0 && !headers["Content-Type"]) {
+    if (operation.requestBody?.content) {
+      const contentTypes = Object.keys(operation.requestBody.content);
+      if (contentTypes.length > 0) {
+        headers["Content-Type"] = contentTypes[0];
+      }
+    } else {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  logger.debug(`Built request: ${operation.method} ${path}`, {
+    query,
+    headers,
+    body: body ? "(body present)" : "(no body)"
+  });
+  return {
+    path,
+    query,
+    headers,
+    body
+  };
+}
+function appendQueryString(url, query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        params.append(key, v);
+      }
+    } else {
+      params.append(key, value);
+    }
+  }
+  const queryString = params.toString();
+  if (queryString) {
+    return `${url}?${queryString}`;
+  }
+  return url;
+}
+
+// src/executor/http-client.ts
+async function executeRequest(operation, input, config) {
+  const baseUrl = config.baseUrl || "";
+  try {
+    const built = buildRequest(operation, input, config.headers || {});
+    let url = `${baseUrl}${built.path}`;
+    url = appendQueryString(url, built.query);
+    logger.info(`Executing: ${operation.method} ${url}`);
+    const requestInit = {
+      method: operation.method,
+      headers: built.headers
+    };
+    if (built.body !== void 0 && !["GET", "HEAD"].includes(operation.method.toUpperCase())) {
+      requestInit.body = typeof built.body === "string" ? built.body : JSON.stringify(built.body);
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+    requestInit.signal = controller.signal;
+    const response = await fetch(url, requestInit);
+    clearTimeout(timeoutId);
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+    let body;
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      try {
+        body = await response.json();
+      } catch {
+        body = await response.text();
+      }
+    } else if (contentType.includes("text/")) {
+      body = await response.text();
+    } else {
+      try {
+        body = await response.json();
+      } catch {
+        body = await response.text();
+      }
+    }
+    logger.debug(`Response status: ${response.status}`);
+    if (!response.ok) {
+      throw new HttpError(
+        `HTTP ${response.status} ${response.statusText}`,
+        response.status,
+        typeof body === "string" ? body : JSON.stringify(body)
+      );
+    }
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+      body
+    };
+  } catch (error) {
+    if (error instanceof HttpError) {
+      throw error;
+    }
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        throw new ToolExecutionError(
+          `Request timeout after ${config.timeout}ms`,
+          operation.operationId || operation.path
+        );
+      }
+      throw new ToolExecutionError(
+        `Request failed: ${error.message}`,
+        operation.operationId || operation.path,
+        error
+      );
+    }
+    throw new ToolExecutionError(
+      "Unknown error during request execution",
+      operation.operationId || operation.path
+    );
+  }
+}
+function formatResponse(response) {
+  const lines = [];
+  lines.push(`Status: ${response.status} ${response.statusText}`);
+  if (Object.keys(response.headers).length > 0) {
+    lines.push("Headers:");
+    for (const [key, value] of Object.entries(response.headers)) {
+      lines.push(`  ${key}: ${value}`);
+    }
+  }
+  lines.push("Body:");
+  if (typeof response.body === "object" && response.body !== null) {
+    lines.push(JSON.stringify(response.body, null, 2));
+  } else {
+    lines.push(String(response.body));
+  }
+  return lines.join("\n");
+}
+
+// src/parser/swagger.ts
+var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"));
+function isOpenAPIV3(doc) {
+  return "openapi" in doc;
+}
+function convertParameter(param) {
+  return {
+    name: param.name,
+    in: param.in,
+    required: param.required,
+    description: param.description,
+    schema: param.schema,
+    deprecated: param.deprecated
+  };
+}
+function convertSchema2(schema) {
+  if (!schema) return void 0;
+  return schema;
+}
+function convertRequestBody(requestBody) {
+  if (!requestBody) return void 0;
+  if ("$ref" in requestBody) {
+    return void 0;
+  }
+  const content = {};
+  for (const [contentType, mediaType] of Object.entries(requestBody.content || {})) {
+    const mt = mediaType;
+    content[contentType] = {
+      schema: convertSchema2(mt.schema),
+      example: mt.example
+    };
+  }
+  return {
+    description: requestBody.description,
+    required: requestBody.required,
+    content
+  };
+}
+function extractOperations(doc) {
+  const operations = [];
+  if (!doc.paths) return operations;
+  const methods = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+  for (const [path, pathItem] of Object.entries(doc.paths)) {
+    if (!pathItem) continue;
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) continue;
+      const parameters = [];
+      if (pathItem.parameters) {
+        for (const param of pathItem.parameters) {
+          if (!("$ref" in param)) {
+            parameters.push(convertParameter(param));
+          }
+        }
+      }
+      if (operation.parameters) {
+        for (const param of operation.parameters) {
+          if (!("$ref" in param)) {
+            parameters.push(convertParameter(param));
+          }
+        }
+      }
+      const op = {
+        method: method.toUpperCase(),
+        path,
+        operationId: operation.operationId,
+        summary: operation.summary,
+        description: operation.description,
+        tags: operation.tags,
+        parameters: parameters.length > 0 ? parameters : void 0,
+        requestBody: convertRequestBody(
+          operation.requestBody
+        ),
+        deprecated: operation.deprecated
+      };
+      operations.push(op);
+    }
+  }
+  return operations;
+}
+async function parseOpenApi(source) {
+  try {
+    logger.info(`Parsing OpenAPI document from: ${source}`);
+    const api = await import_swagger_parser.default.validate(source);
+    if (!isOpenAPIV3(api)) {
+      if ("swagger" in api) {
+        throw new OpenApiParseError(
+          "OpenAPI v2 (Swagger) is not supported. Please convert to OpenAPI v3 first."
+        );
+      }
+      throw new OpenApiParseError("Unsupported OpenAPI format");
+    }
+    const info = {
+      title: api.info.title,
+      version: api.info.version,
+      description: api.info.description
+    };
+    const servers = api.servers?.map((s) => ({
+      url: s.url,
+      description: s.description,
+      variables: s.variables
+    }));
+    const operations = extractOperations(api);
+    const components = api.components ? {
+      schemas: api.components.schemas,
+      parameters: api.components.parameters,
+      requestBodies: api.components.requestBodies
+    } : void 0;
+    logger.info(`Parsed ${operations.length} API operations`);
+    return {
+      openapi: api.openapi,
+      info,
+      servers,
+      operations,
+      components
+    };
+  } catch (error) {
+    if (error instanceof OpenApiParseError) {
+      throw error;
+    }
+    throw new OpenApiParseError(
+      `Failed to parse OpenAPI document: ${error instanceof Error ? error.message : "Unknown error"}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function getBaseUrl(doc, overrideUrl) {
+  if (overrideUrl) {
+    logger.debug(`Using override base URL: ${overrideUrl}`);
+    return overrideUrl;
+  }
+  if (doc.servers && doc.servers.length > 0) {
+    const server = doc.servers[0];
+    let url = server.url;
+    if (server.variables) {
+      for (const [name, variable] of Object.entries(server.variables)) {
+        url = url.replace(`{${name}}`, variable.default);
+      }
+    }
+    logger.debug(`Using base URL from OpenAPI servers: ${url}`);
+    return url;
+  }
+  throw new OpenApiParseError("No base URL found in OpenAPI document. Please specify --base-url.");
+}
+
+// src/server/index.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/server/tool-manager.ts
+var ToolManager = class {
+  tools = /* @__PURE__ */ new Map();
+  config;
+  server;
+  constructor(server, config) {
+    this.server = server;
+    this.config = config;
+  }
+  /**
+   * 注册工具
+   */
+  registerTool(tool) {
+    if (this.tools.has(tool.name)) {
+      logger.warn(`Tool already registered: ${tool.name}, overwriting`);
+    }
+    this.tools.set(tool.name, tool);
+    this.server.tool(
+      tool.name,
+      tool.description,
+      tool.inputSchema.shape,
+      async (args) => {
+        return this.executeTool(tool.name, args);
+      }
+    );
+    logger.debug(`Registered tool: ${tool.name}`);
+  }
+  /**
+   * 批量注册工具
+   */
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.registerTool(tool);
+    }
+    logger.info(`Registered ${tools.length} tools`);
+  }
+  /**
+   * 执行工具
+   */
+  async executeTool(toolName, args) {
+    const tool = this.tools.get(toolName);
+    if (!tool) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Tool not found: ${toolName}`
+          }
+        ]
+      };
+    }
+    try {
+      logger.debug(`Executing tool: ${toolName}`, args);
+      const response = await executeRequest(tool.operation, args, this.config);
+      const formattedResponse = formatResponse(response);
+      return {
+        content: [
+          {
+            type: "text",
+            text: formattedResponse
+          }
+        ]
+      };
+    } catch (error) {
+      const errorMessage = error instanceof ToolExecutionError ? `Error: ${error.message}` : `Error: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger.error(`Tool execution failed: ${toolName}`, error);
+      return {
+        content: [
+          {
+            type: "text",
+            text: errorMessage
+          }
+        ]
+      };
+    }
+  }
+  /**
+   * 获取所有已注册的工具名称
+   */
+  getToolNames() {
+    return Array.from(this.tools.keys());
+  }
+  /**
+   * 获取工具数量
+   */
+  getToolCount() {
+    return this.tools.size;
+  }
+};
+
+// src/server/index.ts
+async function createServer(config) {
+  logger.info("Creating MCP server...");
+  const server = new import_mcp.McpServer({
+    name: "api2mcp",
+    version: "0.1.0"
+  });
+  const openApiDoc = await parseOpenApi(config.openapiUrl);
+  let baseUrl;
+  try {
+    baseUrl = getBaseUrl(openApiDoc, config.baseUrl);
+  } catch (error) {
+    if (config.baseUrl) {
+      baseUrl = config.baseUrl;
+    } else {
+      throw error;
+    }
+  }
+  const effectiveConfig = {
+    ...config,
+    baseUrl
+  };
+  const tools = generateTools(
+    openApiDoc.operations,
+    openApiDoc.components?.schemas,
+    config.toolPrefix
+  );
+  const toolManager = new ToolManager(server, effectiveConfig);
+  toolManager.registerTools(tools);
+  logger.info(`Server ready with ${toolManager.getToolCount()} tools`);
+  return server;
+}
+async function startServer(config) {
+  const server = await createServer(config);
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  logger.info("Server started (stdio mode)");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Api2McpError,
+  ConfigurationError,
+  HttpError,
+  OpenApiParseError,
+  ToolExecutionError,
+  ToolManager,
+  convertSchema,
+  createRefResolver,
+  createServer,
+  executeRequest,
+  formatResponse,
+  generateTool,
+  generateTools,
+  getBaseUrl,
+  loadConfig,
+  logger,
+  parseOpenApi,
+  startServer
+});
+//# sourceMappingURL=index.js.map