ebay-mcp 1.4.3

package/build/scripts/auto-setup.js

@@ -0,0 +1,277 @@
+/**
+ * Auto-Setup Script for eBay API MCP Server
+ *
+ * This script automatically:
+ * 1. Detects installed MCP clients (Claude Desktop, Gemini, ChatGPT)
+ * 2. Generates MCP client configurations from .env
+ * 3. Validates environment tokens configuration
+ * 4. Validates the setup
+ *
+ * Usage: npm run auto-setup (or runs automatically after npm install)
+ */
+import { config } from 'dotenv';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+import { homedir, platform } from 'os';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Load environment variables
+config();
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../..');
+// ═══════════════════════════════════════════════════════════════════════════
+// Color Utilities
+// ═══════════════════════════════════════════════════════════════════════════
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+};
+function print(message, color) {
+    const colorCode = color ? colors[color] : '';
+    console.log(`${colorCode}${message}${colors.reset}`);
+}
+function printSuccess(message) {
+    print(`✅ ${message}`, 'green');
+}
+function printWarning(message) {
+    print(`⚠️  ${message}`, 'yellow');
+}
+function printError(message) {
+    print(`❌ ${message}`, 'red');
+}
+function printInfo(message) {
+    print(`ℹ️  ${message}`, 'cyan');
+}
+function printHeader(message) {
+    print('\n═══════════════════════════════════════════════════════════════════════════', 'blue');
+    print(`  ${message}`, 'cyan');
+    print('═══════════════════════════════════════════════════════════════════════════\n', 'blue');
+}
+function getConfigPaths() {
+    const home = homedir();
+    const os = platform();
+    const paths = {};
+    // Claude Desktop config paths
+    if (os === 'darwin') {
+        paths.claude = join(home, 'Library/Application Support/Claude/claude_desktop_config.json');
+    }
+    else if (os === 'win32') {
+        paths.claude = join(home, 'AppData/Roaming/Claude/claude_desktop_config.json');
+    }
+    else {
+        paths.claude = join(home, '.config/Claude/claude_desktop_config.json');
+    }
+    // Gemini config path
+    paths.gemini = join(home, '.config/gemini/config.json');
+    // ChatGPT config path
+    paths.chatgpt = join(home, '.config/chatgpt/config.json');
+    return paths;
+}
+function detectMCPClients() {
+    const configPaths = getConfigPaths();
+    const clients = [];
+    for (const [name, configPath] of Object.entries(configPaths)) {
+        const detected = existsSync(configPath) || existsSync(dirname(configPath));
+        clients.push({
+            name,
+            configPath,
+            detected,
+        });
+    }
+    return clients;
+}
+function generateMCPServerConfig() {
+    const buildPath = join(PROJECT_ROOT, 'build/index.js');
+    const config = {
+        command: 'node',
+        args: [buildPath],
+        env: {
+            EBAY_CLIENT_ID: process.env.EBAY_CLIENT_ID || '',
+            EBAY_CLIENT_SECRET: process.env.EBAY_CLIENT_SECRET || '',
+            EBAY_ENVIRONMENT: process.env.EBAY_ENVIRONMENT || 'sandbox',
+        },
+    };
+    // Add optional environment variables if they exist
+    if (process.env.EBAY_REDIRECT_URI) {
+        config.env.EBAY_REDIRECT_URI = process.env.EBAY_REDIRECT_URI;
+    }
+    if (process.env.EBAY_USER_ACCESS_TOKEN) {
+        config.env.EBAY_USER_ACCESS_TOKEN = process.env.EBAY_USER_ACCESS_TOKEN;
+    }
+    if (process.env.EBAY_USER_REFRESH_TOKEN) {
+        config.env.EBAY_USER_REFRESH_TOKEN = process.env.EBAY_USER_REFRESH_TOKEN;
+    }
+    if (process.env.EBAY_APP_ACCESS_TOKEN) {
+        config.env.EBAY_APP_ACCESS_TOKEN = process.env.EBAY_APP_ACCESS_TOKEN;
+    }
+    return config;
+}
+function updateClientConfig(client, serverConfig) {
+    try {
+        // Ensure directory exists
+        const configDir = dirname(client.configPath);
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        let config = { mcpServers: {} };
+        if (existsSync(client.configPath)) {
+            try {
+                const existing = readFileSync(client.configPath, 'utf-8');
+                const parsed = JSON.parse(existing);
+                config = {
+                    ...parsed,
+                    mcpServers: parsed.mcpServers || {},
+                };
+            }
+            catch (error) {
+                printWarning(`Invalid JSON in ${client.configPath}, creating backup and new config`);
+                const backup = `${client.configPath}.backup.${Date.now()}`;
+                writeFileSync(backup, readFileSync(client.configPath));
+                printInfo(`Backup saved to: ${backup}`);
+                config = { mcpServers: {} };
+            }
+        }
+        // Update eBay server config
+        config.mcpServers.ebay = serverConfig;
+        // Write config
+        writeFileSync(client.configPath, JSON.stringify(config, null, 2));
+        return true;
+    }
+    catch (error) {
+        printError(`Failed to update ${client.name} config: ${error}`);
+        return false;
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Token Validation (Environment-based only)
+// ═══════════════════════════════════════════════════════════════════════════
+function validateTokens() {
+    // Check if user refresh token is provided in .env
+    const hasUserRefreshToken = process.env.EBAY_USER_REFRESH_TOKEN;
+    if (!hasUserRefreshToken) {
+        printInfo('No EBAY_USER_REFRESH_TOKEN in .env - will use app tokens (1k req/day)');
+        printInfo('For higher rate limits (10k-50k req/day), add EBAY_USER_REFRESH_TOKEN to .env');
+        return true; // Not an error, just informational
+    }
+    printSuccess('User refresh token found in .env - high rate limits enabled');
+    return true;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Validation
+// ═══════════════════════════════════════════════════════════════════════════
+function validateEnvironment() {
+    const errors = [];
+    const warnings = [];
+    // Check .env file exists
+    const envPath = join(PROJECT_ROOT, '.env');
+    if (!existsSync(envPath)) {
+        errors.push('.env file not found. Copy .env.example to .env and fill in your credentials.');
+        return { valid: false, errors, warnings };
+    }
+    // Check required variables
+    if (!process.env.EBAY_CLIENT_ID) {
+        errors.push('EBAY_CLIENT_ID is not set in .env');
+    }
+    if (!process.env.EBAY_CLIENT_SECRET) {
+        errors.push('EBAY_CLIENT_SECRET is not set in .env');
+    }
+    const environment = process.env.EBAY_ENVIRONMENT;
+    if (environment && environment !== 'production' && environment !== 'sandbox') {
+        errors.push(`EBAY_ENVIRONMENT must be "production" or "sandbox", got: "${environment}"`);
+    }
+    if (!process.env.EBAY_REDIRECT_URI) {
+        warnings.push('EBAY_REDIRECT_URI is not set - user OAuth flow will not work. This is required for 10k-50k req/day rate limits.');
+    }
+    // Check build directory exists
+    const buildPath = join(PROJECT_ROOT, 'build/index.js');
+    if (!existsSync(buildPath)) {
+        warnings.push('Build directory not found. Run "npm run build" first.');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Main
+// ═══════════════════════════════════════════════════════════════════════════
+async function main() {
+    printHeader('eBay API MCP Server - Auto Setup');
+    // Step 1: Validate environment
+    printInfo('Step 1/4: Validating environment configuration...');
+    const validation = validateEnvironment();
+    if (validation.errors.length > 0) {
+        printError('Environment validation failed:');
+        validation.errors.forEach((error) => print(`  • ${error}`, 'red'));
+        print('\nPlease fix these errors and run again.', 'yellow');
+        process.exit(1);
+    }
+    if (validation.warnings.length > 0) {
+        validation.warnings.forEach((warning) => printWarning(warning));
+    }
+    printSuccess('Environment validation passed');
+    // Step 2: Detect MCP clients
+    print('\nStep 2/4: Detecting installed MCP clients...');
+    const clients = detectMCPClients();
+    const detectedClients = clients.filter((c) => c.detected);
+    if (detectedClients.length === 0) {
+        printWarning('No MCP clients detected on this system');
+        printInfo('Supported clients: Claude Desktop, Gemini, ChatGPT');
+        printInfo('Install a client and run this script again');
+    }
+    else {
+        printSuccess(`Detected ${detectedClients.length} MCP client(s):`);
+        detectedClients.forEach((client) => {
+            print(`  • ${client.name.charAt(0).toUpperCase() + client.name.slice(1)}`, 'green');
+        });
+    }
+    // Step 3: Generate configurations
+    if (detectedClients.length > 0) {
+        print('\nStep 3/4: Generating MCP client configurations...');
+        const serverConfig = generateMCPServerConfig();
+        for (const client of detectedClients) {
+            const success = updateClientConfig(client, serverConfig);
+            if (success) {
+                printSuccess(`Generated config for ${client.name} at: ${client.configPath}`);
+                client.configGenerated = true;
+            }
+        }
+    }
+    else {
+        print('\nStep 3/4: Skipping config generation (no clients detected)');
+    }
+    // Step 4: Validate tokens
+    print('\nStep 4/4: Validating token configuration...');
+    validateTokens();
+    // Final summary
+    printHeader('Setup Complete! 🎉');
+    const generatedCount = detectedClients.filter((c) => c.configGenerated).length;
+    if (generatedCount > 0) {
+        printSuccess(`Successfully configured ${generatedCount} MCP client(s)`);
+        print('\n📝 Next Steps:', 'cyan');
+        print('  1. Restart your MCP clients (Claude Desktop, Gemini, etc.)');
+        print('  2. Verify connection in MCP client settings/logs');
+        print('  3. Test with: "List my eBay inventory items"');
+        if (validation.warnings.some((w) => w.includes('EBAY_REDIRECT_URI'))) {
+            print('\n💡 Pro Tip:', 'yellow');
+            print('  Add EBAY_REDIRECT_URI to .env for user OAuth (10k-50k req/day rate limits)');
+        }
+    }
+    else {
+        printInfo('No configurations generated (no MCP clients detected)');
+        print('\n📝 To complete setup:', 'cyan');
+        print('  1. Install an MCP client (Claude Desktop, Gemini, or ChatGPT)');
+        print('  2. Run: npm run auto-setup');
+    }
+    print('\n📚 Documentation: https://github.com/YosefHayim/ebay-mcp#readme\n');
+}
+// Run the script
+main().catch((error) => {
+    printError(`Auto-setup failed: ${error}`);
+    process.exit(1);
+});

package/build/scripts/diagnostics.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Diagnostics Script - Troubleshooting and system health checks
+ *
+ * Usage:
+ *   npm run diagnose
+ *   npx ebay-mcp --diagnose
+ */
+export {};

package/build/scripts/diagnostics.js

@@ -0,0 +1,299 @@
+/**
+ * Diagnostics Script - Troubleshooting and system health checks
+ *
+ * Usage:
+ *   npm run diagnose
+ *   npx ebay-mcp --diagnose
+ */
+import chalk from 'chalk';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { runSecurityChecks, displaySecurityResults } from '../utils/security-checker.js';
+import { validateSetup, displayRecommendations } from '../utils/setup-validator.js';
+import { detectLLMClients } from '../utils/llm-client-detector.js';
+import { displayScopeVerification, parseScopeString } from '../utils/scope-helper.js';
+import { EbaySellerApi } from '../api/index.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = join(__dirname, '../..');
+/**
+ * Parse .env file
+ */
+function parseEnvFile(filePath) {
+    const env = {};
+    if (!existsSync(filePath)) {
+        return env;
+    }
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        const match = /^([^=]+)=(.*)$/.exec(trimmed);
+        if (match) {
+            const key = match[1].trim();
+            let value = match[2].trim();
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            env[key] = value;
+        }
+    }
+    return env;
+}
+/**
+ * Check API connectivity
+ */
+async function checkApiConnectivity() {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const response = await fetch('https://api.ebay.com/health', {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        return { canReachEbay: response.ok || response.status === 404 };
+    }
+    catch (error) {
+        return {
+            canReachEbay: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Test eBay API authentication
+ */
+async function testEbayAuthentication(config) {
+    try {
+        const api = new EbaySellerApi(config);
+        await api.initialize();
+        // Try to get user info
+        const userInfo = await api.identity.getUser();
+        return { success: true, userInfo };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Display diagnostic header
+ */
+function displayHeader() {
+    console.clear();
+    console.log(chalk.bold.cyan(`
+╔══════════════════════════════════════════════════════════════╗
+║                                                              ║
+║              eBay MCP Server Diagnostics                     ║
+║                                                              ║
+╚══════════════════════════════════════════════════════════════╝
+  `));
+    console.log(chalk.gray(`Run date: ${new Date().toISOString()}\n`));
+}
+/**
+ * Display system information
+ */
+function displaySystemInfo() {
+    console.log(chalk.bold.cyan('💻 System Information\n'));
+    console.log(`  ${chalk.gray('Node.js:')} ${process.version}`);
+    console.log(`  ${chalk.gray('Platform:')} ${process.platform}`);
+    console.log(`  ${chalk.gray('Architecture:')} ${process.arch}`);
+    console.log(`  ${chalk.gray('CWD:')} ${process.cwd()}`);
+    console.log('');
+}
+/**
+ * Display configuration status
+ */
+function displayConfigurationStatus(envVars) {
+    console.log(chalk.bold.cyan('⚙️  Configuration Status\n'));
+    const checks = [
+        { key: 'EBAY_CLIENT_ID', label: 'Client ID', redact: true },
+        { key: 'EBAY_CLIENT_SECRET', label: 'Client Secret', redact: true },
+        { key: 'EBAY_REDIRECT_URI', label: 'Redirect URI', redact: false },
+        { key: 'EBAY_ENVIRONMENT', label: 'Environment', redact: false },
+        { key: 'EBAY_USER_REFRESH_TOKEN', label: 'User Refresh Token', redact: true },
+        { key: 'EBAY_USER_ACCESS_TOKEN', label: 'User Access Token', redact: true },
+        { key: 'EBAY_APP_ACCESS_TOKEN', label: 'App Access Token', redact: true },
+    ];
+    for (const check of checks) {
+        const value = envVars[check.key];
+        let status;
+        let displayValue;
+        if (value && value.trim() && !value.includes('_here')) {
+            status = chalk.green('✓ Set');
+            displayValue = check.redact ? `${value.substring(0, 10)}...` : value;
+        }
+        else {
+            status = chalk.red('✗ Not set');
+            displayValue = chalk.gray('(not configured)');
+        }
+        console.log(`  ${status} ${chalk.bold(check.label)}: ${displayValue}`);
+    }
+    console.log('');
+}
+/**
+ * Display LLM client status
+ */
+function displayLLMClientStatus() {
+    console.log(chalk.bold.cyan('🤖 LLM Client Detection\n'));
+    const clients = detectLLMClients();
+    for (const client of clients) {
+        const detected = client.detected ? chalk.green('✓ Detected') : chalk.gray('✗ Not found');
+        const configured = client.configExists
+            ? chalk.green('[Configured]')
+            : chalk.gray('[Not configured]');
+        console.log(`  ${detected} ${chalk.bold(client.displayName)} ${configured}`);
+        if (client.detected) {
+            console.log(chalk.gray(`    Config: ${client.configPath}`));
+        }
+    }
+    console.log('');
+}
+/**
+ * Test API authentication and display results
+ */
+async function displayAuthenticationTest(config) {
+    console.log(chalk.bold.cyan('🔐 API Authentication Test\n'));
+    const result = await testEbayAuthentication(config);
+    if (result.success) {
+        console.log(chalk.green('  ✓ Successfully authenticated with eBay API\n'));
+        if (result.userInfo) {
+            console.log(chalk.bold.white('  User Information:'));
+            console.log(chalk.gray(JSON.stringify(result.userInfo, null, 2)));
+            console.log('');
+        }
+    }
+    else {
+        console.log(chalk.red('  ✗ Authentication failed\n'));
+        console.log(chalk.yellow(`  Error: ${result.error}\n`));
+    }
+}
+/**
+ * Generate diagnostic report
+ */
+async function generateDiagnosticReport(exportPath) {
+    const envPath = join(PROJECT_ROOT, '.env');
+    const envVars = parseEnvFile(envPath);
+    // Run security checks
+    const securityResults = await runSecurityChecks(PROJECT_ROOT);
+    // Run configuration validation
+    const validationSummary = await validateSetup(PROJECT_ROOT);
+    // Detect LLM clients
+    const llmClients = detectLLMClients();
+    // Check API connectivity
+    const apiConnection = await checkApiConnectivity();
+    const report = {
+        timestamp: new Date().toISOString(),
+        environment: {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+        },
+        security: securityResults,
+        configuration: validationSummary,
+        llmClients,
+        apiConnection,
+    };
+    // If we have credentials, test authentication
+    if (envVars.EBAY_CLIENT_ID && envVars.EBAY_CLIENT_SECRET) {
+        const config = {
+            clientId: envVars.EBAY_CLIENT_ID,
+            clientSecret: envVars.EBAY_CLIENT_SECRET,
+            redirectUri: envVars.EBAY_REDIRECT_URI,
+            environment: (envVars.EBAY_ENVIRONMENT || 'sandbox'),
+        };
+        const authResult = await testEbayAuthentication(config);
+        report.tokenInfo = {
+            hasUserToken: !!envVars.EBAY_USER_REFRESH_TOKEN,
+            hasAppToken: !!envVars.EBAY_APP_ACCESS_TOKEN,
+        };
+        if (authResult.success) {
+            report.tokenInfo.scopes = envVars.EBAY_USER_REFRESH_TOKEN
+                ? parseScopeString(envVars.EBAY_USER_REFRESH_TOKEN)
+                : [];
+        }
+    }
+    // Export report if path provided
+    if (exportPath) {
+        writeFileSync(exportPath, JSON.stringify(report, null, 2), 'utf-8');
+        console.log(chalk.green(`\n✓ Diagnostic report exported to: ${exportPath}\n`));
+    }
+    return report;
+}
+/**
+ * Main diagnostics function
+ */
+async function runDiagnostics(exportReport = false) {
+    displayHeader();
+    displaySystemInfo();
+    // Security checks
+    const securityResults = await runSecurityChecks(PROJECT_ROOT);
+    displaySecurityResults(securityResults);
+    // Configuration status
+    const envPath = join(PROJECT_ROOT, '.env');
+    const envVars = parseEnvFile(envPath);
+    displayConfigurationStatus(envVars);
+    // LLM client detection
+    displayLLMClientStatus();
+    // API connectivity
+    console.log(chalk.bold.cyan('🌐 API Connectivity\n'));
+    const apiConnection = await checkApiConnectivity();
+    if (apiConnection.canReachEbay) {
+        console.log(chalk.green('  ✓ Can reach eBay API servers\n'));
+    }
+    else {
+        console.log(chalk.red('  ✗ Cannot reach eBay API servers'));
+        console.log(chalk.yellow(`  Error: ${apiConnection.error}\n`));
+    }
+    // Configuration validation
+    console.log(chalk.bold.cyan('📋 Configuration Validation\n'));
+    const validationSummary = await validateSetup(PROJECT_ROOT);
+    displayRecommendations(validationSummary);
+    // If we have credentials, test authentication
+    if (envVars.EBAY_CLIENT_ID && envVars.EBAY_CLIENT_SECRET) {
+        const config = {
+            clientId: envVars.EBAY_CLIENT_ID,
+            clientSecret: envVars.EBAY_CLIENT_SECRET,
+            redirectUri: envVars.EBAY_REDIRECT_URI,
+            environment: (envVars.EBAY_ENVIRONMENT || 'sandbox'),
+        };
+        await displayAuthenticationTest(config);
+        // Scope verification if user has refresh token
+        if (envVars.EBAY_USER_REFRESH_TOKEN) {
+            try {
+                const api = new EbaySellerApi(config);
+                await api.initialize();
+                const authClient = api.getAuthClient();
+                const tokenInfo = authClient.getTokenInfo();
+                if (tokenInfo.scopeInfo) {
+                    displayScopeVerification(tokenInfo.scopeInfo.tokenScopes, config.environment);
+                }
+            }
+            catch {
+                console.log(chalk.yellow('⚠️  Could not verify token scopes\n'));
+            }
+        }
+    }
+    // Export report if requested
+    if (exportReport) {
+        const reportPath = join(PROJECT_ROOT, `ebay-mcp-diagnostic-${Date.now()}.json`);
+        await generateDiagnosticReport(reportPath);
+    }
+    console.log(chalk.bold.green('✅ Diagnostics complete!\n'));
+    console.log(chalk.gray('For more help, visit:'));
+    console.log(chalk.blue.underline('  https://github.com/YosefHayim/ebay-mcp#troubleshooting\n'));
+}
+// CLI handler
+const args = process.argv.slice(2);
+const exportReport = args.includes('--export') || args.includes('-e');
+runDiagnostics(exportReport).catch((error) => {
+    console.error(chalk.red('\n❌ Diagnostics failed:'), error);
+    process.exit(1);
+});

package/build/scripts/download-specs.d.ts

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