ebay-mcp 1.4.3

package/build/utils/scope-helper.js

@@ -0,0 +1,207 @@
+/**
+ * Scope Helper - Manages eBay OAuth scopes
+ */
+import chalk from 'chalk';
+import { getDefaultScopes } from '../config/environment.js';
+/**
+ * Get all available scope categories
+ */
+export function getScopeCategories() {
+    return [
+        {
+            name: 'Inventory Management',
+            description: 'Create, read, update, and delete inventory items',
+            scopes: ['https://api.ebay.com/oauth/api_scope/sell.inventory'],
+            required: true,
+        },
+        {
+            name: 'Order Fulfillment',
+            description: 'View and manage orders, shipping, and fulfillment',
+            scopes: [
+                'https://api.ebay.com/oauth/api_scope/sell.fulfillment',
+                'https://api.ebay.com/oauth/api_scope/sell.fulfillment.readonly',
+            ],
+            required: true,
+        },
+        {
+            name: 'Account Management',
+            description: 'Manage account settings, policies, and preferences',
+            scopes: [
+                'https://api.ebay.com/oauth/api_scope/sell.account',
+                'https://api.ebay.com/oauth/api_scope/sell.account.readonly',
+            ],
+            required: true,
+        },
+        {
+            name: 'Analytics & Reports',
+            description: 'Access sales analytics and performance reports',
+            scopes: [
+                'https://api.ebay.com/oauth/api_scope/sell.analytics.readonly',
+                'https://api.ebay.com/oauth/api_scope/sell.marketplace.insights.readonly',
+            ],
+            required: false,
+        },
+        {
+            name: 'Marketing & Promotions',
+            description: 'Create and manage marketing campaigns and promotions',
+            scopes: [
+                'https://api.ebay.com/oauth/api_scope/sell.marketing',
+                'https://api.ebay.com/oauth/api_scope/sell.marketing.readonly',
+            ],
+            required: false,
+        },
+        {
+            name: 'Finance & Payments',
+            description: 'Access financial data and payment information',
+            scopes: ['https://api.ebay.com/oauth/api_scope/sell.finances'],
+            required: false,
+        },
+        {
+            name: 'Reputation & Feedback',
+            description: 'Manage seller reputation and customer feedback',
+            scopes: ['https://api.ebay.com/oauth/api_scope/sell.reputation'],
+            required: false,
+        },
+        {
+            name: 'Commerce Services',
+            description: 'Identity verification, notifications, and messaging',
+            scopes: [
+                'https://api.ebay.com/oauth/api_scope/commerce.identity.readonly',
+                'https://api.ebay.com/oauth/api_scope/commerce.notification.subscription',
+                'https://api.ebay.com/oauth/api_scope/sell.stores',
+            ],
+            required: false,
+        },
+    ];
+}
+/**
+ * Get recommended scopes for the environment
+ */
+export function getRecommendedScopes(environment) {
+    return getDefaultScopes(environment);
+}
+/**
+ * Display scope selection interface
+ */
+export function displayScopeCategories() {
+    console.log(chalk.bold.cyan('\n📋 Available OAuth Scopes\n'));
+    const categories = getScopeCategories();
+    for (const category of categories) {
+        const badge = category.required ? chalk.green('[Required]') : chalk.gray('[Optional]');
+        console.log(`${badge} ${chalk.bold.white(category.name)}`);
+        console.log(`  ${chalk.gray(category.description)}`);
+        console.log(chalk.gray(`  Scopes: ${category.scopes.length}`));
+        console.log('');
+    }
+}
+/**
+ * Verify if token has required scopes
+ */
+export function verifyScopesCoverage(tokenScopes, requiredScopes) {
+    const tokenScopeSet = new Set(tokenScopes);
+    const requiredScopeSet = new Set(requiredScopes);
+    const missingScopes = requiredScopes.filter((scope) => !tokenScopeSet.has(scope));
+    const extraScopes = tokenScopes.filter((scope) => !requiredScopeSet.has(scope));
+    return {
+        hasAllRequired: missingScopes.length === 0,
+        missingScopes,
+        extraScopes,
+    };
+}
+/**
+ * Display scope verification results
+ */
+export function displayScopeVerification(tokenScopes, environment) {
+    console.log(chalk.bold.cyan('\n🔍 Scope Verification\n'));
+    const recommendedScopes = getRecommendedScopes(environment);
+    const verification = verifyScopesCoverage(tokenScopes, recommendedScopes);
+    console.log(chalk.bold.white('Token Scopes:'));
+    console.log(chalk.gray(`  Total: ${tokenScopes.length}\n`));
+    if (verification.hasAllRequired) {
+        console.log(chalk.green('✓ Token has all recommended scopes\n'));
+    }
+    else {
+        console.log(chalk.yellow('⚠️  Token is missing some recommended scopes\n'));
+        console.log(chalk.bold.white('Missing Scopes:'));
+        for (const scope of verification.missingScopes) {
+            console.log(chalk.yellow(`  • ${scope}`));
+        }
+        console.log('');
+    }
+    if (verification.extraScopes.length > 0) {
+        console.log(chalk.gray('Additional Scopes (not in recommended list):'));
+        for (const scope of verification.extraScopes) {
+            console.log(chalk.gray(`  • ${scope}`));
+        }
+        console.log('');
+    }
+    // Display scope categories and their status
+    const categories = getScopeCategories();
+    const tokenScopeSet = new Set(tokenScopes);
+    console.log(chalk.bold.white('Coverage by Category:\n'));
+    for (const category of categories) {
+        const hasAllCategoryScopes = category.scopes.every((scope) => tokenScopeSet.has(scope));
+        const hasSomeCategoryScopes = category.scopes.some((scope) => tokenScopeSet.has(scope));
+        let status;
+        if (hasAllCategoryScopes) {
+            status = chalk.green('✓ Full');
+        }
+        else if (hasSomeCategoryScopes) {
+            status = chalk.yellow('◐ Partial');
+        }
+        else {
+            status = chalk.red('✗ None');
+        }
+        const badge = category.required ? chalk.red('[Required]') : chalk.gray('[Optional]');
+        console.log(`${status} ${badge} ${category.name}`);
+    }
+    console.log('');
+}
+/**
+ * Get scope description
+ */
+export function getScopeDescription(scope) {
+    const descriptions = {
+        'https://api.ebay.com/oauth/api_scope/sell.inventory': 'Manage inventory items and offers',
+        'https://api.ebay.com/oauth/api_scope/sell.fulfillment': 'Manage orders and shipping',
+        'https://api.ebay.com/oauth/api_scope/sell.fulfillment.readonly': 'View orders and shipping',
+        'https://api.ebay.com/oauth/api_scope/sell.account': 'Manage account settings',
+        'https://api.ebay.com/oauth/api_scope/sell.account.readonly': 'View account settings',
+        'https://api.ebay.com/oauth/api_scope/sell.analytics.readonly': 'View analytics and reports',
+        'https://api.ebay.com/oauth/api_scope/sell.marketing': 'Manage marketing campaigns',
+        'https://api.ebay.com/oauth/api_scope/sell.marketing.readonly': 'View marketing campaigns',
+        'https://api.ebay.com/oauth/api_scope/sell.finances': 'View financial data',
+        'https://api.ebay.com/oauth/api_scope/sell.reputation': 'Manage seller reputation',
+        'https://api.ebay.com/oauth/api_scope/commerce.identity.readonly': 'View user identity',
+        'https://api.ebay.com/oauth/api_scope/sell.stores': 'Manage eBay Stores',
+        'https://api.ebay.com/oauth/api_scope/commerce.notification.subscription': 'Manage notification subscriptions',
+        'https://api.ebay.com/oauth/api_scope/sell.marketplace.insights.readonly': 'View marketplace insights',
+    };
+    return descriptions[scope] || 'No description available';
+}
+/**
+ * Format scopes for display
+ */
+export function formatScopesForDisplay(scopes) {
+    return scopes
+        .map((scope) => {
+        const shortName = scope.split('/').pop() || scope;
+        return `  • ${shortName}`;
+    })
+        .join('\n');
+}
+/**
+ * Get all scopes as a space-separated string
+ */
+export function getAllScopesString(environment) {
+    return getRecommendedScopes(environment).join(' ');
+}
+/**
+ * Parse scope string to array
+ */
+export function parseScopeString(scopeString) {
+    return scopeString
+        .split(/\s+/)
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}

package/build/utils/security-checker.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Security Checker - Pre-flight security and environment checks
+ */
+export interface SecurityCheckResult {
+    check: string;
+    passed: boolean;
+    message: string;
+    severity: 'critical' | 'warning' | 'info';
+    fix?: string;
+}
+/**
+ * Check Node.js version meets requirements
+ */
+export declare function checkNodeVersion(): SecurityCheckResult;
+/**
+ * Check if .env is in .gitignore
+ */
+export declare function checkGitignore(projectRoot: string): SecurityCheckResult;
+/**
+ * Check network connectivity to eBay APIs
+ */
+export declare function checkNetworkConnectivity(): Promise<SecurityCheckResult>;
+/**
+ * Check if project is built
+ */
+export declare function checkProjectBuild(projectRoot: string): SecurityCheckResult;
+/**
+ * Check if dependencies are installed
+ */
+export declare function checkDependencies(projectRoot: string): SecurityCheckResult;
+/**
+ * Check if git repo is initialized and .env is not tracked
+ */
+export declare function checkGitTracking(projectRoot: string): SecurityCheckResult;
+/**
+ * Run all security checks
+ */
+export declare function runSecurityChecks(projectRoot: string): Promise<SecurityCheckResult[]>;
+/**
+ * Display security check results
+ */
+export declare function displaySecurityResults(results: SecurityCheckResult[]): void;
+/**
+ * Check if there are critical failures
+ */
+export declare function hasCriticalFailures(results: SecurityCheckResult[]): boolean;

package/build/utils/security-checker.js

@@ -0,0 +1,248 @@
+/**
+ * Security Checker - Pre-flight security and environment checks
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+/**
+ * Check Node.js version meets requirements
+ */
+export function checkNodeVersion() {
+    const requiredVersion = 18;
+    const currentVersion = parseInt(process.version.slice(1).split('.')[0], 10);
+    if (currentVersion >= requiredVersion) {
+        return {
+            check: 'Node.js Version',
+            passed: true,
+            message: `Node.js ${process.version} meets requirements (>= ${requiredVersion})`,
+            severity: 'info',
+        };
+    }
+    return {
+        check: 'Node.js Version',
+        passed: false,
+        message: `Node.js ${process.version} is below required version ${requiredVersion}`,
+        severity: 'critical',
+        fix: `Install Node.js ${requiredVersion} or higher from https://nodejs.org/`,
+    };
+}
+/**
+ * Check if .env is in .gitignore
+ */
+export function checkGitignore(projectRoot) {
+    const gitignorePath = join(projectRoot, '.gitignore');
+    if (!existsSync(gitignorePath)) {
+        return {
+            check: '.gitignore Security',
+            passed: false,
+            message: 'No .gitignore file found',
+            severity: 'warning',
+            fix: 'Create a .gitignore file and add .env to it',
+        };
+    }
+    const gitignoreContent = readFileSync(gitignorePath, 'utf-8');
+    const hasEnv = gitignoreContent.split('\n').some((line) => {
+        const trimmed = line.trim();
+        return trimmed === '.env' || trimmed === '*.env' || trimmed.startsWith('.env');
+    });
+    if (hasEnv) {
+        return {
+            check: '.gitignore Security',
+            passed: true,
+            message: '.env files are properly ignored by git',
+            severity: 'info',
+        };
+    }
+    return {
+        check: '.gitignore Security',
+        passed: false,
+        message: '.env is not in .gitignore - credentials could be committed!',
+        severity: 'critical',
+        fix: 'Add ".env" to your .gitignore file immediately',
+    };
+}
+/**
+ * Check network connectivity to eBay APIs
+ */
+export async function checkNetworkConnectivity() {
+    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);
+        if (response.ok || response.status === 404) {
+            // 404 is fine, means we can reach eBay servers
+            return {
+                check: 'Network Connectivity',
+                passed: true,
+                message: 'Successfully connected to eBay API servers',
+                severity: 'info',
+            };
+        }
+        return {
+            check: 'Network Connectivity',
+            passed: false,
+            message: `Unexpected response from eBay API: ${response.status}`,
+            severity: 'warning',
+            fix: 'Check your internet connection and firewall settings',
+        };
+    }
+    catch (error) {
+        return {
+            check: 'Network Connectivity',
+            passed: false,
+            message: 'Cannot reach eBay API servers',
+            severity: 'critical',
+            fix: 'Check your internet connection, proxy settings, and firewall',
+        };
+    }
+}
+/**
+ * Check if project is built
+ */
+export function checkProjectBuild(projectRoot) {
+    const buildPath = join(projectRoot, 'build', 'index.js');
+    if (existsSync(buildPath)) {
+        return {
+            check: 'Project Build',
+            passed: true,
+            message: 'Project is built and ready',
+            severity: 'info',
+        };
+    }
+    return {
+        check: 'Project Build',
+        passed: false,
+        message: 'Project has not been built yet',
+        severity: 'warning',
+        fix: 'Run "npm run build" to build the project',
+    };
+}
+/**
+ * Check if dependencies are installed
+ */
+export function checkDependencies(projectRoot) {
+    const nodeModulesPath = join(projectRoot, 'node_modules');
+    if (existsSync(nodeModulesPath)) {
+        return {
+            check: 'Dependencies',
+            passed: true,
+            message: 'Dependencies are installed',
+            severity: 'info',
+        };
+    }
+    return {
+        check: 'Project Dependencies',
+        passed: false,
+        message: 'Dependencies not installed',
+        severity: 'critical',
+        fix: 'Run "npm install" to install dependencies',
+    };
+}
+/**
+ * Check if git repo is initialized and .env is not tracked
+ */
+export function checkGitTracking(projectRoot) {
+    const gitPath = join(projectRoot, '.git');
+    const envPath = join(projectRoot, '.env');
+    if (!existsSync(gitPath)) {
+        return {
+            check: 'Git Repository',
+            passed: true,
+            message: 'Not a git repository (no tracking risk)',
+            severity: 'info',
+        };
+    }
+    if (!existsSync(envPath)) {
+        return {
+            check: 'Git Tracking',
+            passed: true,
+            message: '.env file does not exist yet',
+            severity: 'info',
+        };
+    }
+    try {
+        const result = execSync('git ls-files .env', {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+        }).trim();
+        if (result === '') {
+            return {
+                check: 'Git Tracking',
+                passed: true,
+                message: '.env is not tracked by git',
+                severity: 'info',
+            };
+        }
+        return {
+            check: 'Git Tracking',
+            passed: false,
+            message: '.env is tracked by git - SECURITY RISK!',
+            severity: 'critical',
+            fix: 'Run: git rm --cached .env && git commit -m "Remove .env from tracking"',
+        };
+    }
+    catch {
+        return {
+            check: 'Git Tracking',
+            passed: true,
+            message: 'Unable to check git tracking (likely not tracked)',
+            severity: 'info',
+        };
+    }
+}
+/**
+ * Run all security checks
+ */
+export async function runSecurityChecks(projectRoot) {
+    const results = [];
+    // Synchronous checks
+    results.push(checkNodeVersion());
+    results.push(checkGitignore(projectRoot));
+    results.push(checkProjectBuild(projectRoot));
+    results.push(checkDependencies(projectRoot));
+    results.push(checkGitTracking(projectRoot));
+    // Asynchronous checks
+    results.push(await checkNetworkConnectivity());
+    return results;
+}
+/**
+ * Display security check results
+ */
+export function displaySecurityResults(results) {
+    console.log(chalk.bold.cyan('\n🔒 Security & Environment Checks\n'));
+    for (const result of results) {
+        const icon = result.passed ? chalk.green('✓') : chalk.red('✗');
+        const severity = result.severity === 'critical'
+            ? chalk.red('[CRITICAL]')
+            : result.severity === 'warning'
+                ? chalk.yellow('[WARNING]')
+                : chalk.gray('[INFO]');
+        console.log(`${icon} ${chalk.bold(result.check)}: ${severity}`);
+        console.log(`  ${chalk.gray(result.message)}`);
+        if (result.fix) {
+            console.log(`  ${chalk.yellow('→ Fix:')} ${result.fix}`);
+        }
+        console.log('');
+    }
+    const critical = results.filter((r) => !r.passed && r.severity === 'critical');
+    const warnings = results.filter((r) => !r.passed && r.severity === 'warning');
+    if (critical.length > 0) {
+        console.log(chalk.red.bold(`⚠️  ${critical.length} critical issue(s) found. Please fix before continuing.\n`));
+    }
+    else if (warnings.length > 0) {
+        console.log(chalk.yellow.bold(`⚠️  ${warnings.length} warning(s) found. Recommended to fix.\n`));
+    }
+    else {
+        console.log(chalk.green.bold('✅ All security checks passed!\n'));
+    }
+}
+/**
+ * Check if there are critical failures
+ */
+export function hasCriticalFailures(results) {
+    return results.some((r) => !r.passed && r.severity === 'critical');
+}

package/build/utils/setup-validator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Setup Validation Module
+ *
+ * Tests the configuration after setup to ensure everything is working properly.
+ */
+export interface ValidationResult {
+    test: string;
+    passed: boolean;
+    message: string;
+    error?: string;
+}
+export interface ValidationSummary {
+    totalTests: number;
+    passed: number;
+    failed: number;
+    results: ValidationResult[];
+}
+/**
+ * Run all validation tests
+ */
+export declare function validateSetup(projectRoot: string): Promise<ValidationSummary>;
+/**
+ * Display recommendations based on validation results
+ */
+export declare function displayRecommendations(summary: ValidationSummary): void;