ebay-mcp-remote-edition 4.3.1 → 4.5.1

package/build/api/browse/browse.js

@@ -0,0 +1,43 @@
+import { getBaseUrl } from '../../config/environment.js';
+/**
+ * Browse API - Search and browse eBay product catalog
+ * Based on: eBay Buy Browse API
+ * Base endpoint: /buy/browse/v1
+ */
+export class BrowseApi {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Search the eBay product catalog by query.
+     * Supports category filtering, sorting, and price filtering.
+     */
+    async searchProducts(query, options) {
+        const environment = this.client.getConfig().environment;
+        const browseUrl = new URL('/buy/browse/v1/item_summary/search', getBaseUrl(environment)).toString();
+        const params = { q: query };
+        if (options?.categoryId)
+            params.category_ids = options.categoryId;
+        if (options?.limit)
+            params.limit = options.limit;
+        if (options?.sort)
+            params.sort = options.sort;
+        if (options?.filter)
+            params.filter = options.filter;
+        if (options?.aspectFilter)
+            params.aspect_filter = options.aspectFilter;
+        return await this.client.getWithFullUrl(browseUrl, params);
+    }
+    /**
+     * Get listing/product suggestions based on search query.
+     * Returns relevant item summaries with pricing and shipping info.
+     */
+    async getSuggestions(query, options) {
+        return await this.searchProducts(query, {
+            marketplaceId: options?.marketplaceId,
+            limit: options?.limit ?? 20,
+            sort: 'bestMatch',
+        });
+    }
+}

package/build/api/client-trading.js

@@ -49,7 +49,7 @@ export class TradingApiClient {
      * Handles nested objects like PrimaryCategory, ShippingDetails, ReturnPolicy,
      * PicturesDetails, and ItemSpecifics that require special XML structure.
      */
-    transformItemForXML(item) {
+    transformItemForXML(item, options = { ensureCountry: true }) {
         const transformed = {};
         for (const [key, value] of Object.entries(item)) {
             if (value === undefined || value === null)
@@ -117,6 +117,13 @@ export class TradingApiClient {
                 transformed.Currency = 'USD';
             }
         }
+        // Ensure Country is present for full listing creation/publish transforms.
+        // ReviseFixedPriceItem may update only a subset of fields; injecting a default Country
+        // can accidentally attempt to change an active listing's country and eBay rejects it as
+        // "Input data is invalid." Skip this default for partial revise payloads.
+        if (options.ensureCountry !== false && !transformed.Country) {
+            transformed.Country = 'USA';
+        }
         return transformed;
     }
     /**
@@ -124,13 +131,14 @@ export class TradingApiClient {
      * eBay Trading API expects: <StartPrice currencyID="USD">34.99</StartPrice>
      */
     transformPrice(price) {
-        if (typeof price === 'string') {
-            return price;
+        if (typeof price === 'string' || typeof price === 'number') {
+            return String(price);
         }
+        const currencyID = price.currencyID ?? price.currency;
         // Use fast-xml-parser attribute convention: @_<attrName> for attributes, #text for content
         return {
             '#text': String(price.value),
-            ...(price.currencyID && { '@_currencyID': price.currencyID }),
+            ...(currencyID && { '@_currencyID': currencyID }),
         };
     }
     /**
@@ -264,7 +272,7 @@ export class TradingApiClient {
         // Transform Item field for proper XML serialization
         const transformedParams = { ...params };
         if (transformedParams.Item && typeof transformedParams.Item === 'object') {
-            transformedParams.Item = this.transformItemForXML(transformedParams.Item);
+            transformedParams.Item = this.transformItemForXML(transformedParams.Item, { ensureCountry: callName !== 'ReviseFixedPriceItem' });
         }
         const xmlObj = {};
         xmlObj[requestTag] = {

package/build/api/index.js

@@ -19,6 +19,7 @@ import { EDeliveryApi } from '../api/other/edelivery.js';
 import { IdentityApi } from '../api/other/identity.js';
 import { TranslationApi } from '../api/other/translation.js';
 import { VeroApi } from '../api/other/vero.js';
+import { BrowseApi } from '../api/browse/browse.js';
 import { TradingApiClient } from '../api/client-trading.js';
 import { TradingApi } from '../api/trading/trading.js';
 export class EbaySellerApi {
@@ -44,6 +45,7 @@ export class EbaySellerApi {
     developer;
     media;
     trading;
+    browse;
     constructor(config, context) {
         this.client = new EbayApiClient(config, context);
         this.account = new AccountApi(this.client);
@@ -68,6 +70,7 @@ export class EbaySellerApi {
         this.media = new MediaApi(this.client);
         const tradingClient = new TradingApiClient(this.client);
         this.trading = new TradingApi(tradingClient);
+        this.browse = new BrowseApi(this.client);
     }
     async initialize() {
         await this.client.initialize();
@@ -110,3 +113,4 @@ export * from '../api/other/vero.js';
 export * from '../api/developer/developer.js';
 export * from '../api/trading/trading.js';
 export * from '../api/client-trading.js';
+export * from '../api/browse/browse.js';

package/build/api/listing-management/inventory.js

@@ -360,17 +360,15 @@ export class InventoryApi {
         }
     }
     /**
-     * Get all offers
+     * Get offers for a specific SKU (sku is required)
      * @throws Error if parameters are invalid
      */
     async getOffers(sku, marketplaceId, limit) {
         const params = {};
-        if (sku !== undefined) {
-            if (typeof sku !== 'string') {
-                throw new Error('sku must be a string when provided');
-            }
-            params.sku = sku;
+        if (!sku || typeof sku !== 'string') {
+            throw new Error('sku is required for getOffers');
         }
+        params.sku = sku;
         if (marketplaceId !== undefined) {
             if (typeof marketplaceId !== 'string') {
                 throw new Error('marketplaceId must be a string when provided');

package/build/api/media/media.js

@@ -1,12 +1,13 @@
-import { getBaseUrl } from '../../config/environment.js';
+import { processImageForUpload, } from '../../utils/image-processor.js';
 import axios from 'axios';
+import * as fs from 'fs';
 /**
  * Commerce Media API (v1_beta) - Upload and manage images via eBay Picture Services
  * Based on: https://developer.ebay.com/api-docs/commerce/media/resources/image/from_url/methods
  */
 export class MediaApi {
     client;
-    basePath = '/commerce/media/v1';
+    basePath = '/commerce/media/v1_beta';
     constructor(client) {
         this.client = client;
     }
@@ -15,16 +16,18 @@ export class MediaApi {
     }
     getMediaBaseUrl() {
         const env = this.client.getConfig().environment;
-        return getBaseUrl(env);
+        return env === 'production' ? 'https://apim.ebay.com' : 'https://apim.sandbox.ebay.com';
     }
     /**
      * Upload an image from a public URL to eBay Picture Services.
      *
-     * Steps:
-     * 1. POST /commerce/media/v1/image/from_url to create the image
-     * 2. GET /commerce/media/v1/image/{imageId} to retrieve the hosted URL
+     * Primary flow: Pass URL directly to eBay's createImageFromUrl endpoint
+     * (eBay downloads and processes server-side — no local processing needed).
      *
-     * Supported formats: JPG, GIF, PNG, BMP, TIFF, AVIF, HEIC, WEBP
+     * Fallback: If eBay rejects the image (e.g., too small for 500px minimum),
+     * download → enlarge with Sharp → upload via createImageFromFile.
+     *
+     * Supported source formats: JPG, GIF, PNG, BMP, TIFF, AVIF, HEIC, WEBP
      * Max file size: 10MB per image
      *
      * @param imageUrl - Public URL of the image to upload
@@ -38,20 +41,20 @@ export class MediaApi {
         const token = await this.getAccessToken();
         const baseUrl = this.getMediaBaseUrl();
         try {
-            // Step 1: Create image from URL
+            // Primary: Pass URL directly to eBay — they handle server-side download
             const body = { imageUrl };
             if (description) {
-                Object.assign(body, { description });
+                body.description = description;
             }
-            const createResponse = await axios.post(`${baseUrl}${this.basePath}/image/from_url`, body, {
+            const createResponse = await axios.post(`${baseUrl}${this.basePath}/image/create_image_from_url`, body, {
                 headers: {
                     Authorization: `Bearer ${token}`,
                     'Content-Type': 'application/json',
+                    Accept: 'application/json',
                     Prefer: 'return=representation',
                 },
                 timeout: 30000,
             });
-            // Extract image ID from response body or Location header
             const responseData = createResponse.data;
             const imageId = typeof responseData.id === 'string'
                 ? responseData.id
@@ -59,9 +62,79 @@ export class MediaApi {
             if (!imageId) {
                 throw new Error('No image ID returned from create endpoint');
             }
-            // Step 2: Fetch image details to get the eBay-hosted URL
             return await this.getImage(imageId);
         }
+        catch (primaryError) {
+            // Fallback: if eBay rejects (e.g., image too small), download → Sharp enlarge → upload via file
+            if (axios.isAxiosError(primaryError)) {
+                const status = primaryError.response?.status;
+                // Only fallback on errors that suggest image quality/size issues
+                if (status && (status === 400 || status === 500)) {
+                    try {
+                        console.log(`[MediaApi] Direct URL upload failed (status ${status}), falling back to Sharp processing for: ${imageUrl}`);
+                        // Download the image
+                        const downloadResponse = await axios.get(imageUrl, {
+                            responseType: 'arraybuffer',
+                            timeout: 30000,
+                            maxContentLength: 10 * 1024 * 1024, // 10MB max
+                        });
+                        const imageBuffer = Buffer.from(downloadResponse.data);
+                        // Process with Sharp (enlarge if too small, convert to JPEG)
+                        const processed = await processImageForUpload(imageBuffer);
+                        // Upload via file endpoint
+                        return await this.uploadProcessedImage(processed.buffer, processed.metadata, token, baseUrl, description);
+                    }
+                    catch {
+                        // If fallback also fails, throw the original error (more actionable)
+                        throw primaryError;
+                    }
+                }
+            }
+            // Re-throw non-retryable errors as-is
+            if (axios.isAxiosError(primaryError)) {
+                const status = primaryError.response?.status;
+                const data = primaryError.response?.data;
+                const message = typeof data === 'object' && data !== null && 'errors' in data
+                    ? data.errors?.[0]?.longMessage ||
+                        data.errors?.[0]?.message ||
+                        primaryError.message
+                    : primaryError.message;
+                throw new Error(`Failed to upload image from URL (status ${status}): ${message}`, {
+                    cause: primaryError,
+                });
+            }
+            throw new Error(`Failed to upload image from URL: ${primaryError instanceof Error ? primaryError.message : 'Unknown error'}`, { cause: primaryError });
+        }
+    }
+    /**
+     * Upload an image from a local file to eBay Picture Services.
+     *
+     * Endpoint: POST /commerce/media/v1/image/create_image_from_file
+     * Content-Type: multipart/form-data
+     *
+     * Supported formats: JPG, GIF, PNG, BMP, TIFF, AVIF, HEIC, WEBP
+     * Max file size: 10MB per image
+     *
+     * @param filePath - Local file path of the image to upload
+     * @param description - Optional description for the image
+     * @returns Object with image ID and eBay-hosted image URL
+     */
+    async createImageFromFile(filePath, description) {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('filePath is required and must be a string');
+        }
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        const token = await this.getAccessToken();
+        const baseUrl = this.getMediaBaseUrl();
+        try {
+            const fileBuffer = fs.readFileSync(filePath);
+            // Process image — validate dimensions, enlarge to min 500px if too small,
+            // convert to JPEG, and optimize. Uses sharp library.
+            const processed = await processImageForUpload(fileBuffer);
+            return await this.uploadProcessedImage(processed.buffer, processed.metadata, token, baseUrl, description);
+        }
         catch (error) {
             if (axios.isAxiosError(error)) {
                 const status = error.response?.status;
@@ -71,13 +144,69 @@ export class MediaApi {
                         data.errors?.[0]?.message ||
                         error.message
                     : error.message;
-                throw new Error(`Failed to upload image from URL (status ${status}): ${message}`, {
+                throw new Error(`Failed to upload image from file (status ${status}): ${message}`, {
                     cause: error,
                 });
             }
-            throw new Error(`Failed to upload image from URL: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
+            throw new Error(`Failed to upload image from file: ${error instanceof Error ? error.message : 'Unknown error'}`, { cause: error });
         }
     }
+    /**
+     * Upload a processed image buffer to eBay Picture Services.
+     *
+     * @param buffer - Processed image buffer
+     * @param metadata - Image metadata
+     * @param token - OAuth access token
+     * @param baseUrl - Media API base URL
+     * @param description - Optional description
+     * @returns Object with image ID and eBay-hosted image URL
+     */
+    async uploadProcessedImage(buffer, metadata, token, baseUrl, description) {
+        // Build multipart/form-data body correctly:
+        // --boundary\r\n
+        // Content-Disposition: imageFile\r\n
+        // Content-Type: image/jpeg\r\n\r\n
+        // [IMAGE BINARY DATA]
+        // --boundary\r\n
+        // Content-Disposition: description\r\n\r\n
+        // [description text]
+        // --boundary--\r\n
+        const boundary = `----FormBoundary${Date.now()}`;
+        const fileName = `image_${Date.now()}.jpg`;
+        const parts = [];
+        // Image file part — headers + binary data
+        const imageHeaders = `--${boundary}\r\n` +
+            `Content-Disposition: form-data; name="imageFile"; filename="${fileName}"\r\n` +
+            `Content-Type: image/jpeg\r\n\r\n`;
+        parts.push(Buffer.from(imageHeaders, 'utf-8'));
+        parts.push(buffer);
+        // Description part (optional)
+        if (description) {
+            const descPart = `--${boundary}\r\n` +
+                `Content-Disposition: form-data; name="description"\r\n\r\n` +
+                `${description}\r\n`;
+            parts.push(Buffer.from(descPart, 'utf-8'));
+        }
+        // Closing boundary
+        parts.push(Buffer.from(`--${boundary}--\r\n`, 'utf-8'));
+        const multipartBody = Buffer.concat(parts);
+        const createResponse = await axios.post(`${baseUrl}${this.basePath}/image/create_image_from_file`, multipartBody, {
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': `multipart/form-data; boundary=${boundary}`,
+                Prefer: 'return=representation',
+            },
+            timeout: 30000,
+        });
+        const responseData = createResponse.data;
+        const imageId = typeof responseData.id === 'string'
+            ? responseData.id
+            : createResponse.headers.location?.split('/').pop();
+        if (!imageId) {
+            throw new Error('No image ID returned from create endpoint');
+        }
+        return await this.getImage(imageId);
+    }
     /**
      * Get image details including the eBay-hosted URL.
      *
@@ -99,9 +228,15 @@ export class MediaApi {
                 timeout: 30000,
             });
             const data = response.data;
+            let imageUrl = data.imageUrl;
+            // eBay Media API returns $_1.JPG thumbnail URL. Convert to full-size (s-l1600.jpg)
+            // which is required for listing images (500px minimum).
+            if (imageUrl?.includes('$_1.JPG')) {
+                imageUrl = imageUrl.replace('$_1.JPG', 's-l1600.jpg');
+            }
             return {
                 id: data.id,
-                imageUrl: data.imageUrl,
+                imageUrl: imageUrl || '',
                 description: typeof data.description === 'string' ? data.description : undefined,
             };
         }

package/build/api/trading/trading.js

@@ -3,6 +3,14 @@ export class TradingApi {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * Transform an item for Trading API XML serialization.
+     * Ensures required fields like Currency and Country are always present.
+     * Used by publish_offer flow to pre-transform inventory items before publishing.
+     */
+    transformItemForXML(item) {
+        return this.client.transformItemForXML(item);
+    }
     async getActiveListings(page = 1, entriesPerPage = 50) {
         const result = await this.client.execute('GetMyeBaySelling', {
             ActiveList: {

package/build/auth/oauth.js

@@ -46,6 +46,7 @@ export class EbayOAuthClient {
                     clientId: this.config.clientId,
                     clientSecret: this.config.clientSecret,
                     redirectUri: this.config.redirectUri,
+                    ruName: this.config.ruName,
                     userAccessToken: tokenData.access_token,
                     userRefreshToken: tokenData.refresh_token || envRefreshToken,
                     tokenType: tokenData.token_type,
@@ -99,6 +100,7 @@ export class EbayOAuthClient {
             clientId: this.config.clientId,
             clientSecret: this.config.clientSecret,
             redirectUri: this.config.redirectUri,
+            ruName: this.config.ruName,
             userAccessToken: accessToken,
             userRefreshToken: refreshToken,
             tokenType: 'Bearer',
@@ -128,8 +130,9 @@ export class EbayOAuthClient {
         return this.appAccessToken;
     }
     async exchangeCodeForToken(code) {
-        if (!this.config.redirectUri) {
-            throw new Error('Redirect URI is required for authorization code exchange');
+        const redirectUriForExchange = this.config.ruName || this.config.redirectUri;
+        if (!redirectUriForExchange) {
+            throw new Error('RuName (EBAY_RUNAME) or redirectUri is required for authorization code exchange');
         }
         const tokenUrl = this.getTokenEndpoint();
         const credentials = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString('base64');
@@ -137,7 +140,7 @@ export class EbayOAuthClient {
             const response = await axios.post(tokenUrl, new URLSearchParams({
                 grant_type: 'authorization_code',
                 code,
-                redirect_uri: this.config.redirectUri,
+                redirect_uri: redirectUriForExchange,
             }).toString(), {
                 headers: {
                     'Content-Type': 'application/x-www-form-urlencoded',
@@ -150,6 +153,7 @@ export class EbayOAuthClient {
                 clientId: this.config.clientId,
                 clientSecret: this.config.clientSecret,
                 redirectUri: this.config.redirectUri,
+                ruName: this.config.ruName,
                 userAccessToken: tokenData.access_token,
                 userRefreshToken: tokenData.refresh_token,
                 tokenType: tokenData.token_type,
@@ -195,6 +199,7 @@ export class EbayOAuthClient {
             clientId: this.config.clientId,
             clientSecret: this.config.clientSecret,
             redirectUri: this.config.redirectUri,
+            ruName: this.config.ruName,
             userAccessToken: tokenData.access_token,
             userRefreshToken: tokenData.refresh_token || this.userTokens.userRefreshToken,
             tokenType: tokenData.token_type,
@@ -215,6 +220,7 @@ export class EbayOAuthClient {
             hasRefreshToken: !!this.userTokens?.userRefreshToken,
             hasAccessToken: !!this.userTokens?.userAccessToken,
             hasRedirectUri: !!this.config.redirectUri,
+            hasRuName: !!this.config.ruName,
             ...(this.userTokens?.userRefreshTokenExpiry
                 ? { refreshTokenExpiry: this.userTokens.userRefreshTokenExpiry }
                 : {}),

package/build/config/environment.js

@@ -268,19 +268,18 @@ export function getEbayConfig(environmentOverride) {
         : process.env.EBAY_SANDBOX_CLIENT_SECRET || process.env.EBAY_CLIENT_SECRET || '';
     // Preferred var is EBAY_RUNAME (clearer naming — it IS the RuName, not a URL).
     // EBAY_REDIRECT_URI is kept for backward compatibility.
+    // RuName is for token exchange; redirectUri is for browser OAuth flow. Separate purposes.
+    const fallbackRuName = environment === 'production'
+        ? process.env.EBAY_PRODUCTION_RUNAME || process.env.EBAY_RUNAME || ''
+        : process.env.EBAY_SANDBOX_RUNAME || process.env.EBAY_RUNAME || '';
     const fallbackRedirectUri = environment === 'production'
-        ? process.env.EBAY_PRODUCTION_RUNAME ||
-            process.env.EBAY_PRODUCTION_REDIRECT_URI ||
-            process.env.EBAY_RUNAME ||
-            process.env.EBAY_REDIRECT_URI
-        : process.env.EBAY_SANDBOX_RUNAME ||
-            process.env.EBAY_SANDBOX_REDIRECT_URI ||
-            process.env.EBAY_RUNAME ||
-            process.env.EBAY_REDIRECT_URI;
+        ? process.env.EBAY_PRODUCTION_REDIRECT_URI || process.env.EBAY_REDIRECT_URI || ''
+        : process.env.EBAY_SANDBOX_REDIRECT_URI || process.env.EBAY_REDIRECT_URI || '';
     return {
         clientId: secretConfig?.clientId || fallbackClientId,
         clientSecret: secretConfig?.clientSecret || fallbackClientSecret,
-        redirectUri: secretConfig?.redirectUri || fallbackRedirectUri,
+        redirectUri: secretConfig?.redirectUri || fallbackRedirectUri || undefined,
+        ruName: secretConfig?.ruName || fallbackRuName || undefined,
         marketplaceId: (process.env.EBAY_MARKETPLACE_ID ?? '').trim() || 'EBAY_US',
         contentLanguage: (process.env.EBAY_CONTENT_LANGUAGE ?? '').trim() || 'en-US',
         environment,

package/build/scripts/update-api-status-doc.js

@@ -32,7 +32,25 @@ function buildMarkdown(items) {
 async function main() {
     const { items, error } = await getApiStatusFeed({ limit: DEFAULT_LIMIT });
     if (error && items.length === 0) {
-        throw new Error(`Failed to fetch API status feed: ${error}`);
+        // Feed is temporarily unavailable — write a fallback doc instead of failing
+        const fallback = [
+            '# eBay API Status (cached)',
+            '',
+            'The eBay API Status RSS feed is currently unavailable. Last attempt:',
+            `*${new Date().toISOString()}*`,
+            '',
+            `**Error:** ${error}`,
+            '',
+            'Full list: [developer.ebay.com/support/api-status](https://developer.ebay.com/support/api-status).',
+            '',
+            '---',
+            '',
+            '*Generated by [ebay-mcp-remote-edition](https://github.com/mrnajiboy/ebay-mcp-remote-edition) API status sync.*',
+        ].join('\n');
+        writeFileSync(OUT_PATH, fallback, 'utf8');
+        console.warn(`Feed unavailable (${error}), wrote fallback to ${OUT_PATH}`);
+        process.exitCode = 0;
+        return;
     }
     const markdown = buildMarkdown(items);
     writeFileSync(OUT_PATH, markdown, 'utf8');

package/build/server-http.js

@@ -745,7 +745,7 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
             serverLogger.info(`[${prefix || 'root'}/authorize] Credential check`, {
                 environment,
                 envSource,
-                ruName: ebayConfig.redirectUri,
+                ruName: ebayConfig.ruName || ebayConfig.redirectUri,
                 ruNameDetectedEnv: credCheck.detectedEnv,
                 credentialValid: credCheck.valid,
             });
@@ -770,7 +770,7 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
             serverLogger.info(`[${prefix || 'root'}/authorize] Redirecting to eBay OAuth`, {
                 state: stateRecord.state,
                 environment,
-                ruName: ebayConfig.redirectUri,
+                ruName: ebayConfig.ruName || ebayConfig.redirectUri,
                 expectedCallbackUrl: getExpectedOAuthCallbackUrl(serverUrl),
             });
             res.redirect(oauthUrl);
@@ -874,7 +874,7 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
             serverLogger.info(`[${prefix || 'root'}/oauth/start] Redirecting to eBay OAuth`, {
                 state: stateRecord.state,
                 environment,
-                ruName: ebayConfig.redirectUri,
+                ruName: ebayConfig.ruName || ebayConfig.redirectUri,
                 expectedCallbackUrl: getExpectedOAuthCallbackUrl(serverUrl),
                 returnTo,
             });
@@ -966,17 +966,42 @@ function mountEnvRouter(hardcodedEnv, serverUrl, iconBaseUrl) {
                 { src: `${iconBaseUrl}/48x48.png`, mimeType: 'image/png', sizes: ['48x48'] },
             ],
         });
+        // Configurable tool execution timeout (60s default — most tools complete in <10s)
+        // Longer than individual API timeouts (30s) to allow for token refresh + API chaining
+        const TOOL_TIMEOUT_MS = Number(process.env.MCP_TOOL_TIMEOUT_MS ?? 60_000);
         const tools = getToolDefinitions();
         for (const toolDef of tools) {
             try {
                 server.registerTool(toolDef.name, { description: toolDef.description, inputSchema: toolDef.inputSchema }, async (args) => {
+                    const startTime = Date.now();
                     try {
-                        const result = await executeTool(api, toolDef.name, args);
+                        // Wrap tool execution with timeout to prevent indefinite hangs
+                        const result = await Promise.race([
+                            executeTool(api, toolDef.name, args),
+                            new Promise((_, reject) => {
+                                setTimeout(() => reject(new Error(`Tool ${toolDef.name} timed out after ${TOOL_TIMEOUT_MS}ms`)), TOOL_TIMEOUT_MS);
+                            }),
+                        ]);
+                        const duration = Date.now() - startTime;
+                        serverLogger.info(`[tool-exec] ${toolDef.name}`, {
+                            userId,
+                            environment,
+                            durationMs: duration,
+                            status: 'success',
+                        });
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     catch (error) {
+                        const duration = Date.now() - startTime;
+                        serverLogger.warn(`[tool-exec] ${toolDef.name}`, {
+                            userId,
+                            environment,
+                            durationMs: duration,
+                            status: 'error',
+                            error: error instanceof Error ? error.message : String(error),
+                        });
                         return {
                             content: [
                                 {
@@ -1132,7 +1157,7 @@ async function handleOAuthCallback(req, res, serverUrl) {
             environment,
             tokenBaseUrl: getBaseUrl(environment),
             clientIdPrefix: ebayConfig.clientId ? `${ebayConfig.clientId.slice(0, 12)}...` : '(missing)',
-            ruName: ebayConfig.redirectUri ?? '(missing)',
+            ruName: (ebayConfig.ruName || ebayConfig.redirectUri) ?? '(missing)',
         });
         const userId = randomUUID();
         const api = await createUserScopedApi(userId, environment);