ebay-mcp-remote-edition 1.0.0

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.js

@@ -0,0 +1,305 @@
+/**
+ * Setup Validation Module
+ *
+ * Tests the configuration after setup to ensure everything is working properly.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { EbayOAuthClient } from '../auth/oauth.js';
+import { getOAuthAuthorizationUrl } from '../config/environment.js';
+/**
+ * Parse .env file manually
+ */
+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();
+        // Skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#')) {
+            continue;
+        }
+        // Parse KEY=VALUE
+        const match = /^([^=]+)=(.*)$/.exec(trimmed);
+        if (match) {
+            const key = match[1].trim();
+            let value = match[2].trim();
+            // Remove quotes if present
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            env[key] = value;
+        }
+    }
+    return env;
+}
+/**
+ * Validate .env file exists and is readable
+ */
+function validateEnvFile(projectRoot) {
+    const envPath = join(projectRoot, '.env');
+    if (!existsSync(envPath)) {
+        return {
+            test: '.env File Existence',
+            passed: false,
+            message: 'Configuration file not found',
+            error: `.env file does not exist at ${envPath}`,
+        };
+    }
+    try {
+        readFileSync(envPath, 'utf-8');
+        return {
+            test: '.env File Existence',
+            passed: true,
+            message: 'Configuration file exists and is readable',
+        };
+    }
+    catch (error) {
+        return {
+            test: '.env File Existence',
+            passed: false,
+            message: 'Configuration file cannot be read',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Validate required app credentials are present
+ */
+function validateAppCredentials(envVars) {
+    const required = ['EBAY_CLIENT_ID', 'EBAY_CLIENT_SECRET', 'EBAY_REDIRECT_URI'];
+    const missing = [];
+    for (const key of required) {
+        if (!envVars[key] || envVars[key].trim() === '') {
+            missing.push(key);
+        }
+    }
+    if (missing.length > 0) {
+        return {
+            test: 'App Credentials',
+            passed: false,
+            message: 'Missing required app credentials',
+            error: `Missing: ${missing.join(', ')}`,
+        };
+    }
+    return {
+        test: 'App Credentials',
+        passed: true,
+        message: 'All required app credentials are present',
+    };
+}
+/**
+ * Validate environment setting
+ */
+function validateEnvironment(envVars) {
+    const env = envVars.EBAY_ENVIRONMENT || 'sandbox';
+    if (env !== 'sandbox' && env !== 'production') {
+        return {
+            test: 'Environment Setting',
+            passed: false,
+            message: 'Invalid environment value',
+            error: `EBAY_ENVIRONMENT must be "sandbox" or "production", got "${env}"`,
+        };
+    }
+    return {
+        test: 'Environment Setting',
+        passed: true,
+        message: `Environment set to "${env}"`,
+    };
+}
+/**
+ * Check if user tokens are configured
+ */
+function validateUserTokens(envVars) {
+    const hasRefreshToken = envVars.EBAY_USER_REFRESH_TOKEN && envVars.EBAY_USER_REFRESH_TOKEN.trim() !== '';
+    if (!hasRefreshToken) {
+        return {
+            test: 'User Tokens (Optional)',
+            passed: true,
+            message: 'No user tokens configured (app token only mode)',
+            error: 'To enable user-specific API calls, set EBAY_USER_REFRESH_TOKEN',
+        };
+    }
+    return {
+        test: 'User Tokens',
+        passed: true,
+        message: 'User refresh token is configured',
+    };
+}
+/**
+ * Test OAuth client initialization
+ */
+async function validateOAuthInitialization(config) {
+    try {
+        const oauthClient = new EbayOAuthClient(config);
+        await oauthClient.initialize();
+        return {
+            test: 'OAuth Client Initialization',
+            passed: true,
+            message: 'OAuth client initialized successfully',
+        };
+    }
+    catch (error) {
+        return {
+            test: 'OAuth Client Initialization',
+            passed: false,
+            message: 'Failed to initialize OAuth client',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Test OAuth URL generation
+ */
+function validateOAuthURL(config) {
+    try {
+        if (!config.redirectUri) {
+            return {
+                test: 'OAuth URL Generation',
+                passed: false,
+                message: 'Redirect URI is required for OAuth URL generation',
+                error: 'EBAY_REDIRECT_URI is not configured',
+            };
+        }
+        const url = getOAuthAuthorizationUrl(config.clientId, config.redirectUri, config.environment);
+        if (!url.startsWith('http')) {
+            return {
+                test: 'OAuth URL Generation',
+                passed: false,
+                message: 'Invalid OAuth URL generated',
+                error: 'Generated URL is not valid',
+            };
+        }
+        return {
+            test: 'OAuth URL Generation',
+            passed: true,
+            message: 'OAuth URL can be generated',
+        };
+    }
+    catch (error) {
+        return {
+            test: 'OAuth URL Generation',
+            passed: false,
+            message: 'Failed to generate OAuth URL',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Run all validation tests
+ */
+export async function validateSetup(projectRoot) {
+    const results = [];
+    console.log(chalk.bold.cyan('\n🧪 Running Configuration Tests...\n'));
+    // Test 1: .env file exists
+    const envFileResult = validateEnvFile(projectRoot);
+    results.push(envFileResult);
+    printResult(envFileResult);
+    if (!envFileResult.passed) {
+        return {
+            totalTests: 1,
+            passed: 0,
+            failed: 1,
+            results,
+        };
+    }
+    // Parse .env file
+    const envPath = join(projectRoot, '.env');
+    const envVars = parseEnvFile(envPath);
+    // Test 2: App credentials
+    const appCredsResult = validateAppCredentials(envVars);
+    results.push(appCredsResult);
+    printResult(appCredsResult);
+    // Test 3: Environment setting
+    const envResult = validateEnvironment(envVars);
+    results.push(envResult);
+    printResult(envResult);
+    // Test 4: User tokens (optional)
+    const userTokensResult = validateUserTokens(envVars);
+    results.push(userTokensResult);
+    printResult(userTokensResult);
+    // If app credentials are valid, test OAuth functionality
+    if (appCredsResult.passed) {
+        const config = {
+            clientId: envVars.EBAY_CLIENT_ID,
+            clientSecret: envVars.EBAY_CLIENT_SECRET,
+            redirectUri: envVars.EBAY_REDIRECT_URI,
+            environment: (envVars.EBAY_ENVIRONMENT || 'sandbox'),
+        };
+        // Test 5: OAuth initialization
+        const oauthInitResult = await validateOAuthInitialization(config);
+        results.push(oauthInitResult);
+        printResult(oauthInitResult);
+        // Test 6: OAuth URL generation
+        if (oauthInitResult.passed) {
+            const oauthURLResult = validateOAuthURL(config);
+            results.push(oauthURLResult);
+            printResult(oauthURLResult);
+        }
+    }
+    // Calculate summary
+    const passed = results.filter((r) => r.passed).length;
+    const failed = results.length - passed;
+    // Print summary
+    console.log(chalk.gray('\n' + '─'.repeat(60)));
+    console.log(chalk.bold.white('\n📊 Validation Summary\n'));
+    console.log(`  Total Tests: ${results.length}`);
+    console.log(`  ${chalk.green('✓ Passed:')} ${passed}`);
+    console.log(`  ${chalk.red('✗ Failed:')} ${failed}`);
+    if (failed === 0) {
+        console.log(chalk.green.bold('\n✨ All tests passed! Configuration is valid.\n'));
+    }
+    else {
+        console.log(chalk.yellow.bold('\n⚠️  Some tests failed. Please review the errors above.\n'));
+    }
+    return {
+        totalTests: results.length,
+        passed,
+        failed,
+        results,
+    };
+}
+/**
+ * Print a single validation result
+ */
+function printResult(result) {
+    const icon = result.passed ? chalk.green('✓') : chalk.red('✗');
+    const status = result.passed ? chalk.green('PASS') : chalk.red('FAIL');
+    console.log(`${icon} ${chalk.bold(result.test)}: ${status}`);
+    console.log(`  ${chalk.gray(result.message)}`);
+    if (result.error) {
+        console.log(`  ${chalk.yellow('→')} ${chalk.yellow(result.error)}`);
+    }
+    console.log('');
+}
+/**
+ * Display recommendations based on validation results
+ */
+export function displayRecommendations(summary) {
+    const hasUserTokens = summary.results.some((r) => r.test === 'User Tokens' && r.passed && !r.error);
+    console.log(chalk.bold.cyan('💡 Recommendations:\n'));
+    if (!hasUserTokens) {
+        console.log(chalk.yellow('  ⚠️  User tokens not configured'));
+        console.log(chalk.gray('     • You can only use app token for limited API access'));
+        console.log(chalk.gray('     • To enable full API access, use the ebay_get_oauth_url tool'));
+        console.log(chalk.gray('     • Then save your refresh token to EBAY_USER_REFRESH_TOKEN in .env\n'));
+    }
+    if (summary.failed > 0) {
+        console.log(chalk.red('  ❌ Configuration has errors'));
+        console.log(chalk.gray('     • Review the failed tests above'));
+        console.log(chalk.gray('     • Update your .env file with correct values'));
+        console.log(chalk.gray('     • Run the setup wizard again: npm run setup\n'));
+    }
+    else {
+        console.log(chalk.green('  ✅ Configuration is complete and valid'));
+        console.log(chalk.gray('     • Restart your MCP client (Claude Desktop, Cline, etc.)'));
+        console.log(chalk.gray('     • The eBay MCP server should now be available'));
+        console.log(chalk.gray('     • Try using tools like: ebay_get_user, ebay_get_oauth_url\n'));
+    }
+}

package/build/utils/token-utils.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for token utility tools
+ */
+export const ConvertDateToTimestampSchema = z
+    .object({
+    dateInput: z
+        .union([z.string(), z.number()])
+        .describe('Date to convert. Supports ISO 8601 strings (e.g., "2025-01-15T10:30:00Z"), Unix timestamps (seconds or milliseconds), or relative time (e.g., "in 2 hours")'),
+})
+    .passthrough();
+export const ValidateTokenExpirySchema = z
+    .object({
+    accessTokenExpiry: z
+        .union([z.string(), z.number()])
+        .describe('Access token expiry time. Can be ISO date string, Unix timestamp (seconds or milliseconds), or relative time'),
+    refreshTokenExpiry: z
+        .union([z.string(), z.number()])
+        .describe('Refresh token expiry time. Can be ISO date string, Unix timestamp (seconds or milliseconds), or relative time'),
+})
+    .passthrough();
+export const SetUserTokensWithExpirySchema = z
+    .object({
+    accessToken: z.string().min(1).describe('eBay user access token'),
+    refreshToken: z.string().min(1).describe('eBay user refresh token'),
+    accessTokenExpiry: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("Optional: Access token expiry time. If not provided, defaults to 2 hours from now. Can be ISO date string, Unix timestamp, or relative time (e.g., 'in 7200 seconds')"),
+    refreshTokenExpiry: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe('Optional: Refresh token expiry time. If not provided, defaults to 18 months from now. Can be ISO date string, Unix timestamp, or relative time'),
+    autoRefresh: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe('If true and access token is expired but refresh token is valid, automatically refresh the access token. Default: true'),
+})
+    .passthrough();

package/build/utils/version.js

@@ -0,0 +1,56 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import updateNotifier from 'update-notifier';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PACKAGE_JSON_PATH = join(__dirname, '../../package.json');
+let cachedPackageJson = null;
+export function getPackageJson() {
+    if (cachedPackageJson) {
+        return cachedPackageJson;
+    }
+    try {
+        const content = readFileSync(PACKAGE_JSON_PATH, 'utf-8');
+        cachedPackageJson = JSON.parse(content);
+        return cachedPackageJson;
+    }
+    catch {
+        return { name: 'ebay-mcp-remote-edition', version: '1.0.0' };
+    }
+}
+export function getVersion() {
+    return getPackageJson().version;
+}
+export function getPackageName() {
+    return getPackageJson().name;
+}
+const ONE_DAY_MS = 1000 * 60 * 60 * 24;
+export function checkForUpdates(options = {}) {
+    const pkg = getPackageJson();
+    const notifier = updateNotifier({
+        pkg,
+        updateCheckInterval: ONE_DAY_MS,
+    });
+    notifier.notify({
+        isGlobal: true,
+        defer: options.defer ?? false,
+        message: 'Update available {currentVersion} → {latestVersion}\n' + 'Run {updateCommand} to update',
+    });
+}
+export async function getUpdateInfo() {
+    const pkg = getPackageJson();
+    const notifier = updateNotifier({
+        pkg,
+        updateCheckInterval: 0,
+    });
+    await notifier.fetchInfo();
+    if (notifier.update && notifier.update.latest !== pkg.version) {
+        return {
+            current: pkg.version,
+            latest: notifier.update.latest,
+            name: pkg.name,
+        };
+    }
+    return undefined;
+}