ebay-api-mcp-server-node-local 1.0.0

package/src/constant/constants.ts

@@ -0,0 +1,51 @@
+/**
+ * Constants used throughout the application
+ */
+
+/**
+ * Environment options for the eBay API
+ */
+export enum ApiEnvironment {
+  SANDBOX = "sandbox",
+  PRODUCTION = "production"
+}
+/**
+ * Utility to find ApiEnvironment by string value
+ * Returns SANDBOX if no match is found
+ */
+export function findApiEnvironmentByValue(value: string): ApiEnvironment {
+  const lowercaseValue = value?.toLowerCase();
+  const matchedEnv = Object.entries(ApiEnvironment)
+    .find(([_key, val]) => typeof val === "string" && val.toLowerCase() === lowercaseValue);
+  return matchedEnv ? matchedEnv[1] as ApiEnvironment : ApiEnvironment.SANDBOX;
+}
+
+/**
+ * Recall apiDoc url by prompt
+ */
+export const RECALL_SPEC_BY_PROMPT_URL = "https://ebaypubapimcp3.vip.qa.ebay.com/developer-portal/api/v1/openapi-specs/search?query=%s";
+/**
+ * url for query apiSpec with fields such as specTitle、operationId
+ */
+export const RECALL_SPEC_WITH_FIELD_URL = "https://ebaypubapimcp3.vip.qa.ebay.com/developer-portal/api/v1/openapi-specs/%s?operationId=%s";
+
+/**
+ * Required environment variable names for the application
+ */
+export const REQUIRED_ENV_VARS = ["EBAY_CLIENT_TOKEN", "EBAY_API_ENV"];
+
+/**
+ * API domain name, differentiated by api environment
+ */
+export const DOMAIN_NAME = {
+  [ApiEnvironment.SANDBOX]: "api.sandbox.ebay.com",
+  [ApiEnvironment.PRODUCTION]: "api.ebay.com",
+};
+
+/**
+ * List of supported calling methods, differentiated by api environment
+ */
+export const SUPPORTED_CALLING_METHODS = {
+  [ApiEnvironment.SANDBOX]: ["get", "put", "post", "delete", "options", "head", "patch", "trace"],
+  [ApiEnvironment.PRODUCTION]: ["get"],
+};

package/src/helper/http-helper.ts

@@ -0,0 +1,154 @@
+/**
+ * Helper functions for HTTP requests
+ */
+import axios from "axios";
+import { type OpenAPIV3 } from "openapi-types";
+import https from "https";
+import { DOMAIN_NAME, findApiEnvironmentByValue } from "../constant/constants.js";
+
+const USER_ENVIRONMENT = findApiEnvironmentByValue(process.env.EBAY_API_ENV || "");
+const USER_TOKEN = process.env.EBAY_CLIENT_TOKEN || "";
+const SCHEMA_REQUEST_BODY = "requestBody";
+
+
+/**
+ * Format axios error message for consistent error output
+ */
+export function formatAxiosError(error: unknown): string {
+  let errorMessage = `Error in invokeAPI tool: ${error instanceof Error ? error.message : String(error)}`;
+  if (axios.isAxiosError(error)) {
+    if (error?.response?.data) {
+      errorMessage = JSON.stringify(error.response.data, null, 2);
+    }
+  }
+  return errorMessage;
+}
+
+/**
+ * Build headers from input headers and fill with default headers
+ */
+export function buildHeadersFromInput(inputHeaders: Record<string, string[]> | undefined): Record<string, string> {
+  const headers: Record<string, string> = {};
+  if (inputHeaders) {
+    for (const [key, value] of Object.entries(inputHeaders)) {
+      headers[key] = Array.isArray(value) ? value[0] : value;
+    }
+  }
+  // Add default headers
+  fillDefaultHeaderInfo(headers);
+  return headers;
+}
+
+export function fillDefaultHeaderInfo(headers: Record<string, string>): void {
+  headers["Host"] = DOMAIN_NAME[USER_ENVIRONMENT];
+  headers["User-Agent"] = "EBAY-API-MCP-Tool/1.0";
+  headers["Authorization"] = `Bearer ${USER_TOKEN}`;
+  headers["Content-Type"] = headers["Content-Type"] || "application/json";
+}
+
+/**
+ * Build final URL by replacing path variables with their values
+ */
+export function buildFinalUrl(url: string, urlVariables: Record<string, unknown> | undefined): string {
+  if (urlVariables) {
+    for (const [key, value] of Object.entries(urlVariables)) {
+      url = url.replace(new RegExp(`%7B${key}%7D`, "g"), encodeURIComponent(String(value)));
+    }
+  }
+  return url;
+}
+
+/**
+ * replace url domain name by environment
+ */
+export function replaceDomainNameByEnvironment(url: string): string {
+  try {
+    const urlObj = new URL(url);
+    const currentHostname = urlObj.hostname;
+    const expectedDomain = DOMAIN_NAME[USER_ENVIRONMENT];
+    if (currentHostname !== expectedDomain) {
+      urlObj.hostname = expectedDomain;
+      return urlObj.toString();
+    }
+    return url;
+  } catch (error) {
+    // Fallback to string replacement if URL parsing fails
+    const expectedDomain = DOMAIN_NAME[USER_ENVIRONMENT];
+    for (const [env, domain] of Object.entries(DOMAIN_NAME)) {
+      if (env !== USER_ENVIRONMENT && url.includes(domain)) {
+        return url.replace(domain, expectedDomain);
+      }
+    }
+    return url;
+  }
+}
+
+/**
+ * Build base URL from OpenAPI servers object
+ */
+export function buildBaseUrlFromOpenApi(openapi: OpenAPIV3.Document): string {
+  const serverObj = openapi.servers?.[0] || { url: "" };
+  let baseUrl = serverObj.url;
+  if (serverObj.variables) {
+    for (const [key, value] of Object.entries(serverObj.variables)) {
+      baseUrl = baseUrl.replace(`{${key}}`, value.default);
+    }
+  }
+  return replaceDomainNameByEnvironment(baseUrl);
+}
+
+/**
+ * Resolve path variables in a URL pattern
+ */
+export function resolvePath(pathPattern: string, pathVariables?: Record<string, string | number>): string {
+  if (!pathVariables) {
+    return pathPattern;
+  }
+
+  return pathPattern.replace(/{([^}]+)}/g, (match, key) => {
+    const value = pathVariables[key];
+    if (value === undefined) {
+      throw new Error(`Missing path variable: ${key}`);
+    }
+    return String(value);
+  });
+}
+
+/**
+ * Prepare request data
+ */
+export function prepareRequestData(
+  input: Record<string, unknown>,
+  operation: OpenAPIV3.OperationObject,
+  path: string,
+): { resolvedPath: string; headers: Record<string, string>; params: Record<string, unknown>; data: unknown; } {
+  let resolvedPath = path;
+  const headers: Record<string, string> = {};
+  const params: Record<string, unknown> = {};
+  let data: unknown = undefined;
+  const pathParams: Record<string, string> = {};
+
+  let prop = input.properties as Record<string, unknown> || {};
+  Object.entries(prop).forEach(([key, value]) => {
+    if (key === SCHEMA_REQUEST_BODY) {
+      data = value;
+    } else {
+      const paramDef = operation.parameters?.find(p =>
+        !("$ref" in p) && p.name === key) as OpenAPIV3.ParameterObject | undefined;
+      if (paramDef) {
+        if (paramDef.in === "header") {
+          headers[key] = String(value);
+        } else if (paramDef.in === "query") {
+          params[key] = value;
+        } else if (paramDef.in === "path") {
+          pathParams[key] = String(value);
+        }
+      }
+    }
+  });
+  fillDefaultHeaderInfo(headers);
+  if (Object.keys(pathParams).length > 0) {
+    resolvedPath = resolvePath(resolvedPath, pathParams);
+  }
+  return { resolvedPath, headers, params, data };
+}

package/src/helper/openapi-helper.ts

@@ -0,0 +1,116 @@
+/**
+ * OpenAPI helper functions, including loading OpenAPI documents,
+ * parsing OpenAPI specs, building schemas, and converting to Zod schemas.
+ */
+import SwaggerParser from "@apidevtools/swagger-parser";
+import { type OpenAPIV3 } from "openapi-types";
+import * as fs from "fs";
+import axios from "axios";
+import * as yaml from "js-yaml";
+import util from "util";
+import { z, type ZodTypeAny } from "zod";
+
+
+const SCHEMA_REQUEST_BODY = "requestBody";
+
+/**
+ * Get OpenAPI docs from user config file, which contains urls or paths of OpenAPI specs.
+ */
+export async function getOpenApiDocumentsFromConfigFile(): Promise<OpenAPIV3.Document[]> {
+  const docs: OpenAPIV3.Document[] = [];
+  const urlFile = process.env.EBAY_API_DOC_URL_FILE;
+  let urls: string[] = [];
+  if (urlFile && fs.existsSync(urlFile)) {
+    // url or path each line in the file
+    urls = fs.readFileSync(urlFile, "utf-8").split(/\r?\n/)
+      .map(line => line.trim())
+      .filter(line => line.length > 0 && !line.startsWith("#"));
+  }
+  console.error("Loading OpenAPI specifications from:", urls);
+  // parse opebapi doc from url/path
+  for (const specPath of urls) {
+    try {
+      const doc = await SwaggerParser.dereference(specPath) as OpenAPIV3.Document;
+      docs.push(doc);
+    } catch (e) {
+      console.error(`getOpenApiDocumentsFromConfigFile#[Failed to load OpenAPI doc from the specPath : ${specPath}]`);
+    }
+  }
+  return docs;
+}
+
+// Helper: remove ignored keys recursively
+export function readSchema2Map(obj: unknown): unknown {
+  const SCHEMA_IGNORE_KEYS = ["style", "explode", "exampleSetFlag", "types", "in", "required"];
+  if (Array.isArray(obj)) {
+    return obj.map(readSchema2Map);
+  } else if (obj && typeof obj === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
+      if (!SCHEMA_IGNORE_KEYS.includes(k)) {
+        out[k] = readSchema2Map(v);
+      }
+    }
+    return out;
+  }
+  return obj;
+}
+
+/**
+ * Parse OpenAPI document from string (supports both JSON and YAML)
+ */
+export async function parseOpenApiDoc(specTitle: string, operationId : string, specUrl: string): Promise<OpenAPIV3.Document> {
+  const url = util.format(specUrl, specTitle, operationId);
+  const apiSpecRes = await axios.get<string>(url,  {
+    httpsAgent: new (await import("https")).Agent({
+      rejectUnauthorized: false,
+    })});
+  const docString = apiSpecRes.data;
+  try {
+    // Try parsing as JSON first
+    return JSON.parse(docString) as OpenAPIV3.Document;
+  } catch (jsonError) {
+    try {
+      // If JSON fails, try parsing as YAML
+      return yaml.load(docString) as OpenAPIV3.Document;
+    } catch (yamlError) {
+      const _jsonMsg = jsonError instanceof Error ? jsonError.message : String(jsonError);
+      const _yamlMsg = yamlError instanceof Error ? yamlError.message : String(yamlError);
+      console.error("failed to parse OpenAPI document !!!");
+      return {} as OpenAPIV3.Document;
+    }
+  }
+}
+
+/**
+ * Build schema for an operation's input parameters
+ */
+export function buildOperationSchema(operation: OpenAPIV3.OperationObject): { properties: Record<string, unknown> } {
+  const properties: Record<string, unknown> = {};
+  // handle request param
+  (operation.parameters || []).forEach(param => {
+    if ("$ref" in param) {return;}
+    const paramSchema = readSchema2Map(param);
+    properties[param.name] = paramSchema;
+  });
+  // handle request body
+  if (operation.requestBody && "content" in operation.requestBody &&
+      operation.requestBody.content?.["application/json"]?.schema) {
+    const requestBodySchema = readSchema2Map(operation.requestBody.content["application/json"].schema);
+    properties[SCHEMA_REQUEST_BODY] = requestBodySchema;
+  }
+  return { properties };
+}
+
+/**
+ * Build Zod validation schema
+ */
+export function buildZodSchema(properties: Record<string, unknown>): Record<string, ZodTypeAny> {
+  const zodProperties: Record<string, ZodTypeAny> = {};
+
+  Object.keys(properties).forEach(key => {
+    zodProperties[key] = z.any();
+  });
+
+  return zodProperties;
+}

package/src/helper/validation-helper.ts

@@ -0,0 +1,289 @@
+/**
+ * Validation helper functions for OpenAPI validation
+ */
+import { type OpenAPIV3 } from "openapi-types";
+import AjvLib from "ajv";
+const Ajv = AjvLib.default || AjvLib;
+
+/**
+ * Validate request parameters against OpenAPI specification
+ */
+export function validateRequestParameters(
+  url: string,
+  openApiDoc: OpenAPIV3.Document,
+  method: string,
+  input: {
+    urlVariables?: Record<string, unknown>;
+    urlQueryParams?: Record<string, unknown>;
+    headers?: Record<string, string>;
+    requestBody?: Record<string, unknown>;
+  },
+): { isValid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  // validate path
+  const {pathValidateRes, apiPath, specPath, specPathItem} = validatePath(openApiDoc, url);
+  if (!pathValidateRes || !specPathItem) {
+    errors.push(`API path ${apiPath} is not valid or not found in OpenAPI specification`);
+    return { isValid: false, errors };
+  }
+
+  // Check if the method exists for the path
+  const operation = specPathItem[method.toLowerCase() as keyof typeof specPathItem] as OpenAPIV3.OperationObject;
+  if (!operation) {
+    errors.push(`Method ${method} not found for path ${specPath} in OpenAPI specification`);
+    return { isValid: false, errors };
+  }
+
+  // Initialize AJV for schema validation
+  const _ajv = new Ajv({ allErrors: true });
+
+  validateUrlPathParam(input.urlVariables, operation.parameters, errors);
+
+  validateUrlQueryParam(input.urlQueryParams, operation.parameters, errors);
+
+  validateUrlHeaders(input.headers, operation.parameters, errors);
+
+  validateUrlRequestBody(input.requestBody, operation.requestBody, errors);
+
+  return { isValid: errors.length === 0, errors };
+}
+
+/**
+ *  Validate the API path against the OpenAPI document
+ */
+export function validatePath(openApiDoc: OpenAPIV3.Document, inputUrl: string): {
+  pathValidateRes : boolean,
+  apiPath : string,
+  specPath : string,
+  specPathItem?: OpenAPIV3.PathItemObject
+} {
+  // Extract the path from the URL (remove base URL part)
+  const apiPath : string = parseApiPathFromUrl(inputUrl);
+  if (!apiPath) {
+    console.error(`input url ${inputUrl} is not valid, please check it.`);
+    return {pathValidateRes : false, apiPath:"", specPath: "", specPathItem: undefined};
+  }
+  // bathPath validation
+  const serverObj = openApiDoc.servers?.[0] || { url: "" };
+  let basePath : string = "";
+  if (serverObj?.variables) {
+    for (const [key, value] of Object.entries(serverObj.variables)) {
+      if (key === "basePath") {
+        basePath = value.default;
+      }
+    }
+  }
+  const basePathRegex = new RegExp(`${basePath.replace(/\{[^}]+\}/g, "[^/]+")  }$`);
+  if (basePath && !basePathRegex.test(apiPath)) {
+    console.error(`API path ${apiPath} does not match the base path ${basePath} in OpenAPI specification.`);
+    return {pathValidateRes : false, apiPath, specPath: "", specPathItem: undefined};
+  }
+
+  // specPath validation
+  for (const specPath of Object.keys(openApiDoc.paths || {})) {
+    const specPathRegex = new RegExp(`${specPath.replace(/\{[^}]+\}/g, "[^/]+")  }$`);
+    if (specPathRegex.test(apiPath) && openApiDoc.paths?.[specPath]) {
+      const specPathItem = openApiDoc.paths[specPath];
+      return { pathValidateRes: true, apiPath, specPath, specPathItem};
+    }
+  }
+
+  return {pathValidateRes : false, apiPath, specPath: "", specPathItem: undefined};
+}
+
+/**
+ *  parse path from the given url by llm
+ */
+export function parseApiPathFromUrl(inputUrl: string): string {
+  try {
+    const urlObj = new URL(inputUrl);
+    return decodeURIComponent(urlObj.pathname); // Decode URL path
+  } catch (urlError) {
+    // If URL parsing fails, try to extract path manually
+    const pathMatch = inputUrl.match(/https?:\/\/[^/]+(.*)$/);
+    if (pathMatch) {
+      return pathMatch[1];
+    }
+    console.error(`Failed to parse API path from URL: ${inputUrl}`);
+    return  "";
+  }
+}
+
+/**
+ *  Validate URL path parameters against OpenAPI specification
+ */
+export function validateUrlPathParam(
+  urlVariables: Record<string, unknown> | undefined,
+  parameters: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[] | undefined,
+  errors: string[],
+): void {
+  // Initialize AJV for schema validation
+  const ajv = new Ajv({ allErrors: true });
+  if (urlVariables) {
+    const pathParams = (parameters || []).filter(
+      (param): param is OpenAPIV3.ParameterObject =>
+        !("$ref" in param) && param.in === "path",
+    );
+
+    for (const param of pathParams) {
+      const value = urlVariables[param.name];
+
+      if (param.required && (value === undefined || value === null)) {
+        errors.push(`Missing required path parameter: ${param.name}`);
+        continue;
+      }
+
+      if (value !== undefined && param.schema) {
+        const validate = ajv.compile(param.schema);
+        if (!validate(value)) {
+          errors.push(`Invalid path parameter ${param.name}: ${ajv.errorsText(validate.errors)}`);
+        }
+      }
+    }
+
+    // Check for extra path parameters not defined in spec
+    const definedPathParams = pathParams.map(p => p.name);
+    const extraParams = Object.keys(urlVariables).filter(key => !definedPathParams.includes(key));
+    if (extraParams.length > 0) {
+      errors.push(`Unknown path parameters: ${extraParams.join(", ")}`);
+    }
+
+    // Check for required path parameters that might be missing from urlVariables
+    const requiredPathParams = (parameters || [])
+      .filter((param): param is OpenAPIV3.ParameterObject =>
+        !("$ref" in param) && param.in === "path" && (param.required === true),
+      )
+      .map(param => param.name);
+    const providedPathParams = Object.keys(urlVariables || {});
+    const missingPathParams = requiredPathParams.filter(param => !providedPathParams.includes(param));
+    if (missingPathParams.length > 0) {
+      errors.push(`Missing required path parameters: ${missingPathParams.join(", ")}`);
+    }
+  }
+}
+
+/**
+ * Validate URL query parameters against OpenAPI specification
+ */
+export function validateUrlQueryParam(
+  urlQueryParams: Record<string, unknown> | undefined,
+  parameters: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[] | undefined,
+  errors: string[],
+): void {
+  const ajv = new Ajv({ allErrors: true });
+  if (urlQueryParams) {
+    const queryParams = (parameters || []).filter(
+      (param): param is OpenAPIV3.ParameterObject =>
+        !("$ref" in param) && param.in === "query",
+    );
+
+    for (const param of queryParams) {
+      const value = urlQueryParams[param.name];
+
+      if (param.required && (value === undefined || value === null || value === "")) {
+        errors.push(`Missing required query parameter: ${param.name}`);
+        continue;
+      }
+
+      if (value !== undefined && param.schema) {
+        const validate = ajv.compile(param.schema);
+        // Convert string values to appropriate types for validation
+        let validationValue = value;
+        if (typeof value === "string" && param.schema && !("$ref" in param.schema) && (param.schema).type) {
+          const schemaObj = param.schema;
+          switch (schemaObj.type) {
+            case "integer":
+            case "number":
+              validationValue = Number(value);
+              break;
+            case "boolean":
+              validationValue = value.toLowerCase() === "true";
+              break;
+            case "array":
+              // Handle comma-separated values for arrays
+              if (param.style === "form" && !param.explode) {
+                validationValue = value.split(",");
+              }
+              break;
+          }
+        }
+
+        if (!validate(validationValue)) {
+          errors.push(`Invalid query parameter ${param.name}: ${ajv.errorsText(validate.errors)}`);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Validate URL headers against OpenAPI specification
+ */
+export function validateUrlHeaders(
+  headers: Record<string, string> | undefined,
+  parameters: (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[] | undefined,
+  errors: string[],
+): void {
+  const ajv = new Ajv({ allErrors: true });
+  if (headers) {
+    const headerParams = (parameters || []).filter(
+      (param): param is OpenAPIV3.ParameterObject =>
+        !("$ref" in param) && param.in === "header",
+    );
+
+    for (const param of headerParams) {
+      const headerName = param.name.toLowerCase();
+      const value = headers[headerName] || headers[param.name];
+
+      if (param.required && (value === undefined || value === null || value === "")) {
+        errors.push(`Missing required header parameter: ${param.name}`);
+        continue;
+      }
+
+      if (value !== undefined && param.schema) {
+        const validate = ajv.compile(param.schema);
+        if (!validate(value)) {
+          errors.push(`Invalid header parameter ${param.name}: ${ajv.errorsText(validate.errors)}`);
+        }
+      }
+    }
+  }
+}
+
+/**
+ *  Validate URL request body against OpenAPI specification
+ */
+export function validateUrlRequestBody(
+  inputBody: Record<string, unknown> | undefined,
+  operationBody: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | undefined,
+  errors: string[],
+): void {
+  const ajv = new Ajv({ allErrors: true, strict: false });
+  if (operationBody && !("$ref" in operationBody)) {
+    const requestBody = operationBody;
+    const isRequired = requestBody.required || false;
+
+    if (isRequired && (!inputBody || Object.keys(inputBody).length === 0)) {
+      errors.push("Missing required request body");
+    } else if (inputBody && Object.keys(inputBody).length > 0) {
+      // Find the appropriate content type schema
+      const contentTypes = ["application/json", "application/x-www-form-urlencoded", "multipart/form-data"];
+      let schema: OpenAPIV3.SchemaObject | undefined;
+
+      for (const contentType of contentTypes) {
+        if (requestBody.content?.[contentType]?.schema) {
+          schema = requestBody.content[contentType].schema as OpenAPIV3.SchemaObject;
+          break;
+        }
+      }
+
+      if (schema) {
+        const validate = ajv.compile(schema);
+        if (!validate(inputBody)) {
+          errors.push(`Invalid request body: ${ajv.errorsText(validate.errors)}`);
+        }
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,75 @@
+// Load environment variables from .env file
+import * as dotenv from "dotenv";
+dotenv.config();
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerOpenApiTools } from "./service/openapi-service.js";
+import * as constants from "./constant/constants.js";
+
+/**
+ * Check if required environment variables are set for eBay API authentication
+ */
+function checkEnvironmentVariables(): void {
+
+  // environment vals check
+  const missingVars = constants.REQUIRED_ENV_VARS.filter(varName => !process.env[varName]);
+
+  if (missingVars.length > 0) {
+    console.error(`Missing required environment variables: ${missingVars.join(", ")}`);
+    process.exit(1);
+  }
+
+  if (process.env.EBAY_ENVIRONMENT &&
+      !["sandbox", "production"].includes(process.env.EBAY_ENVIRONMENT.toLowerCase())) {
+    console.warn("Warning: EBAY_ENVIRONMENT must be either \"sandbox\" or \"production\"");
+    console.warn(`Current value "${process.env.EBAY_ENVIRONMENT}" is invalid, defaulting to "production"`);
+  }
+}
+
+/**
+ * Main function to initialize and run the eBay API MCP Server
+ * This server exposes eBay API endpoints as MCP tools for access via AI models
+ */
+async function main(): Promise<void> {
+  console.error("Starting eBay API MCP Server...");
+  // Check for required environment variables
+  checkEnvironmentVariables();
+  const server = initServer();
+
+  try {
+    // Register the OpenAPI tools with the server
+    await registerOpenApiTools(server);
+    console.error("Successfully registered OpenAPI tools");
+
+    // Create and connect server transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("eBay API MCP Server running on stdio transport");
+
+  } catch (error) {
+    console.error("Error starting MCP server:", error instanceof Error ? error.message : String(error));
+    console.error("Stack trace:", error instanceof Error ? error.stack : "No stack trace available");
+    process.exit(1);
+  }
+}
+
+// Run the server
+main().catch((error) => {
+  console.error("Fatal error:", error instanceof Error ? error.message : String(error));
+  console.error("Stack trace:", error instanceof Error ? error.stack : "No stack trace available");
+  process.exit(1);
+});
+
+
+// Create MCP server instance
+function initServer(): McpServer {
+  return new McpServer({
+    name: "ebay-api-mcp-server",
+    version: "1.0.0",
+    capabilities: {
+      resources: {},
+      tools: {},
+    },
+  });
+}