ebay-mcp 1.4.3

package/build/config/environment.js

@@ -0,0 +1,260 @@
+import { config } from 'dotenv';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { LocaleEnum } from '../types/ebay-enums.js';
+config();
+// Get the current directory for loading scope files
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Load and parse production scopes from JSON file
+ */
+function getProductionScopes() {
+    try {
+        const scopesPath = join(__dirname, '../../docs/auth/production_scopes.json');
+        const scopesData = readFileSync(scopesPath, 'utf-8');
+        const scopes = JSON.parse(scopesData);
+        // Filter out empty objects and extract unique scope strings
+        const uniqueScopes = new Set();
+        scopes.forEach((item) => {
+            if (item.Scope) {
+                uniqueScopes.add(item.Scope);
+            }
+        });
+        return Array.from(uniqueScopes);
+    }
+    catch (error) {
+        console.error('Failed to load production scopes:', error);
+        // Return a minimal set of core scopes as fallback
+        return ['https://api.ebay.com/oauth/api_scope'];
+    }
+}
+/**
+ * Load and parse sandbox scopes from JSON file
+ */
+function getSandboxScopes() {
+    try {
+        const scopesPath = join(__dirname, '../../docs/auth/sandbox_scopes.json');
+        const scopesData = readFileSync(scopesPath, 'utf-8');
+        const scopes = JSON.parse(scopesData);
+        // Filter out empty objects and extract unique scope strings
+        const uniqueScopes = new Set();
+        scopes.forEach((item) => {
+            if (item.Scope) {
+                uniqueScopes.add(item.Scope);
+            }
+        });
+        return Array.from(uniqueScopes);
+    }
+    catch (error) {
+        console.error('Failed to load sandbox scopes:', error);
+        // Return a minimal set of core scopes as fallback
+        return ['https://api.ebay.com/oauth/api_scope'];
+    }
+}
+/**
+ * Get default scopes for the specified environment
+ */
+export function getDefaultScopes(environment) {
+    return environment === 'production' ? getProductionScopes() : getSandboxScopes();
+}
+/**
+ * Validate scopes against environment and return warnings for invalid scopes
+ */
+export function validateScopes(scopes, environment) {
+    const validScopes = getDefaultScopes(environment);
+    const validScopeSet = new Set(validScopes);
+    const warnings = [];
+    const requestedValidScopes = [];
+    scopes.forEach((scope) => {
+        if (validScopeSet.has(scope)) {
+            requestedValidScopes.push(scope);
+        }
+        else {
+            // Check if this is a scope for the other environment
+            const otherEnvironment = environment === 'production' ? 'sandbox' : 'production';
+            const otherScopes = getDefaultScopes(otherEnvironment);
+            if (otherScopes.includes(scope)) {
+                warnings.push(`Scope "${scope}" is only available in ${otherEnvironment} environment, not in ${environment}. This scope will be requested but may be rejected by eBay.`);
+            }
+            else {
+                warnings.push(`Scope "${scope}" is not recognized for ${environment} environment. This scope will be requested but may be rejected by eBay.`);
+            }
+            // Still include it in case it's a new scope not in our JSON files
+            requestedValidScopes.push(scope);
+        }
+    });
+    return { warnings, validScopes: requestedValidScopes };
+}
+/**
+ * Validate environment configuration on startup
+ */
+export function validateEnvironmentConfig() {
+    const warnings = [];
+    const errors = [];
+    // Check required environment variables
+    if (!process.env.EBAY_CLIENT_ID) {
+        errors.push('EBAY_CLIENT_ID is not set. OAuth will not work.');
+    }
+    if (!process.env.EBAY_CLIENT_SECRET) {
+        errors.push('EBAY_CLIENT_SECRET is not set. OAuth will not work.');
+    }
+    // Validate EBAY_ENVIRONMENT
+    const environment = process.env.EBAY_ENVIRONMENT;
+    if (environment && environment !== 'production' && environment !== 'sandbox') {
+        errors.push(`EBAY_ENVIRONMENT must be either "production" or "sandbox", got: "${environment}"`);
+    }
+    // Check if environment is set
+    if (!environment) {
+        warnings.push('EBAY_ENVIRONMENT not set. Defaulting to "sandbox". Set EBAY_ENVIRONMENT=production for production use.');
+    }
+    // Check if redirect URI is set (needed for OAuth user flow)
+    if (!process.env.EBAY_REDIRECT_URI) {
+        warnings.push('EBAY_REDIRECT_URI is not set. User OAuth flow will not work. Set this to enable user token generation.');
+    }
+    // Validate that scope files exist
+    try {
+        getProductionScopes();
+    }
+    catch (error) {
+        errors.push(`Failed to load production scopes: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    try {
+        getSandboxScopes();
+    }
+    catch (error) {
+        errors.push(`Failed to load sandbox scopes: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    const isValid = errors.length === 0;
+    return {
+        isValid,
+        warnings,
+        errors,
+    };
+}
+export function getEbayConfig() {
+    const clientId = process.env.EBAY_CLIENT_ID ?? '';
+    const clientSecret = process.env.EBAY_CLIENT_SECRET ?? '';
+    const environment = (process.env.EBAY_ENVIRONMENT ?? 'sandbox');
+    const accessToken = process.env.EBAY_USER_ACCESS_TOKEN ?? '';
+    const refreshToken = process.env.EBAY_USER_REFRESH_TOKEN ?? '';
+    const appAccessToken = process.env.EBAY_APP_ACCESS_TOKEN ?? '';
+    // Only require client credentials - tokens can be optional (generated from refresh token)
+    if (clientId === '' || clientSecret === '') {
+        console.error('Missing required eBay credentials. Please set:\n1) EBAY_CLIENT_ID\n2) EBAY_CLIENT_SECRET\nin your .env file at project root');
+    }
+    return {
+        clientId,
+        clientSecret,
+        redirectUri: process.env.EBAY_REDIRECT_URI,
+        environment,
+        accessToken,
+        refreshToken,
+        appAccessToken,
+    };
+}
+export function getBaseUrl(environment) {
+    return environment === 'production' ? 'https://api.ebay.com' : 'https://api.sandbox.ebay.com';
+}
+/**
+ * Get base URL for Identity API (uses apiz subdomain)
+ */
+export function getIdentityBaseUrl(environment) {
+    return environment === 'production' ? 'https://apiz.ebay.com' : 'https://apiz.sandbox.ebay.com';
+}
+export function getAuthUrl(clientIdOrEnvironment, redirectUri, environment, locale = LocaleEnum.en_US, prompt = 'login', responseType = 'code', state, scopes) {
+    // If only one argument and it's an environment, return the token endpoint
+    if (arguments.length === 1 && (clientIdOrEnvironment === 'production' || clientIdOrEnvironment === 'sandbox')) {
+        return `${getBaseUrl(clientIdOrEnvironment)}/identity/v1/oauth2/token`;
+    }
+    // Otherwise, generate the full OAuth authorization URL
+    const clientId = clientIdOrEnvironment;
+    const env = environment || 'sandbox';
+    const scope = getDefaultScopes(env);
+    if (!(clientId && redirectUri)) {
+        console.error("clientId, redirectUri (RuName), and scope are required,please initialize the class properly.");
+        return '';
+    }
+    const authDomain = env === 'production' ? 'https://auth.ebay.com' : 'https://auth.sandbox.ebay.com';
+    const params = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: redirectUri,
+        response_type: responseType,
+        scope: scopes?.join(' ') || scope.join(' '),
+        prompt,
+        locale,
+        ...(state ? { state } : {}),
+    });
+    return `${authDomain}/oauth2/authorize?${params.toString()}`;
+}
+/**
+ * Generate the OAuth authorization URL for user consent
+ * This URL should be opened in a browser for the user to grant permissions
+ *
+ * Note: Scopes are optional - eBay will automatically grant the appropriate scopes
+ * based on your application's keyset configuration if scopes are not specified.
+ */
+export function getOAuthAuthorizationUrl(clientId, redirectUri, // MUST be eBay RuName, NOT a URL
+environment, scopes, locale, state) {
+    // Build the authorize URL using auth2 endpoint (correct eBay OAuth endpoint)
+    const authDomain = environment === 'production' ? 'https://auth2.ebay.com' : 'https://auth2.sandbox.ebay.com';
+    const authorizeEndpoint = `${authDomain}/oauth2/authorize`;
+    // Build query parameters for the authorize endpoint
+    const params = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: redirectUri,
+    });
+    // Add scopes only if provided (optional - eBay handles automatically if not specified)
+    if (scopes && scopes.length > 0) {
+        params.append('scope', scopes.join(' '));
+    }
+    else {
+        // Use default scopes for the environment if no scopes are specified
+        const defaultScopes = getDefaultScopes(environment);
+        params.append('scope', defaultScopes.join(' '));
+    }
+    // Always add state parameter (empty if not provided)
+    params.append('state', state || '');
+    // Add response_type
+    params.append('response_type', 'code');
+    // Add hd parameter (required by eBay)
+    params.append('hd', '');
+    // Build the signin URL that redirects to authorize
+    const signinDomain = environment === 'production' ? 'https://signin.ebay.com' : 'https://signin.sandbox.ebay.com';
+    const ruParam = encodeURIComponent(`${authorizeEndpoint}?${params.toString()}`);
+    return `${signinDomain}/signin?ru=${ruParam}&sgfl=oauth2_login&AppName=${clientId}`;
+}
+export const mcpConfig = {
+    name: 'eBay API Model Context Protocol Server',
+    version: '1.4.2',
+    title: 'eBay API Model Context Protocol Server',
+    websiteUrl: 'https://github.com/ebay/ebay-mcp-server',
+    icons: [
+        {
+            src: './48x48.png',
+            mimeType: 'image/png',
+            sizes: ['48x48'],
+        },
+        {
+            src: './128x128.png',
+            mimeType: 'image/png',
+            sizes: ['128x128'],
+        },
+        {
+            src: './256x256.png',
+            mimeType: 'image/png',
+            sizes: ['256x256'],
+        },
+        {
+            src: './512x512.png',
+            mimeType: 'image/png',
+            sizes: ['512x512'],
+        },
+        {
+            src: './1024x1024.png',
+            mimeType: 'image/png',
+            sizes: ['1024x1024'],
+        },
+    ],
+};

package/build/index.d.ts

@@ -0,0 +1 @@
+export {};

package/build/index.js

@@ -0,0 +1,98 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { EbaySellerApi } from './api/index.js';
+import { getEbayConfig, mcpConfig, validateEnvironmentConfig } from './config/environment.js';
+import { getToolDefinitions, executeTool } from './tools/index.js';
+/**
+ * eBay API MCP Server
+ * Provides access to eBay APIs through Model Context Protocol
+ */
+class EbayMcpServer {
+    server;
+    api;
+    constructor() {
+        this.server = new McpServer(mcpConfig);
+        // Initialize eBay API client
+        this.api = new EbaySellerApi(getEbayConfig());
+        this.setupHandlers();
+        this.setupErrorHandling();
+    }
+    /**
+     * Initialize the API (load tokens from storage)
+     */
+    async initialize() {
+        await this.api.initialize();
+    }
+    setupHandlers() {
+        const tools = getToolDefinitions();
+        // Register each tool with the MCP server
+        for (const toolDef of tools) {
+            this.server.registerTool(toolDef.name, {
+                description: toolDef.description,
+                inputSchema: toolDef.inputSchema,
+            }, async (args) => {
+                try {
+                    const result = await executeTool(this.api, toolDef.name, args);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify(result, null, 2),
+                            },
+                        ],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({ error: errorMessage }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+            });
+        }
+    }
+    setupErrorHandling() {
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    async run() {
+        // Validate environment configuration
+        const validation = validateEnvironmentConfig();
+        // Display warnings
+        if (validation.warnings.length > 0) {
+            console.error('\n⚠️  Environment Configuration Warnings:');
+            validation.warnings.forEach((warning) => {
+                console.error(`  • ${warning}`);
+            });
+            console.error('');
+        }
+        // Display errors and exit if configuration is invalid
+        if (!validation.isValid) {
+            console.error('\n❌ Environment Configuration Errors:');
+            validation.errors.forEach((error) => {
+                console.error(`  • ${error}`);
+            });
+            console.error('\nPlease fix the configuration errors and restart the server.\n');
+            process.exit(1);
+        }
+        // Initialize API (load tokens from storage)
+        await this.initialize();
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        console.error('eBay API MCP Server running on stdio');
+    }
+}
+// Start the server
+const server = new EbayMcpServer();
+server.run().catch((error) => {
+    console.error('Fatal error running server:', error);
+    process.exit(1);
+});