ebay-mcp-remote-edition 1.0.0

package/build/utils/api-status-feed.js

@@ -0,0 +1,83 @@
+/**
+ * Fetches and parses the eBay API Status RSS feed (public, no auth).
+ * Used by the ebay_get_api_status MCP tool and optionally by the docs sync script.
+ */
+import { XMLParser } from 'fast-xml-parser';
+import axios from 'axios';
+const RSS_URL = 'https://developer.ebay.com/rss/api-status';
+function stripHtml(html) {
+    return html
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function normalizeString(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value.trim();
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return String(value).trim();
+    return '';
+}
+function parseItem(raw) {
+    const summary = normalizeString(raw.summary) || stripHtml(normalizeString(raw.description)).slice(0, 300) || '';
+    return {
+        title: normalizeString(raw.title) || 'Untitled',
+        summary: summary || normalizeString(raw.title),
+        link: normalizeString(raw.link) || '',
+        api: normalizeString(raw.api) || '',
+        site: normalizeString(raw.site) || '',
+        status: normalizeString(raw.status) || '',
+        lastUpdated: normalizeString(raw.lastUpdated) || '',
+    };
+}
+function ensureArray(value) {
+    if (value == null)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+/**
+ * Fetches the eBay API Status RSS feed, parses it, and returns items
+ * optionally filtered by status and API name, limited to `limit` items.
+ */
+export async function getApiStatusFeed(options = {}) {
+    const { limit = 20, status: statusFilter, api: apiFilter } = options;
+    try {
+        const response = await axios.get(RSS_URL, {
+            timeout: 15_000,
+            responseType: 'text',
+            headers: { Accept: 'application/rss+xml, application/xml, text/xml' },
+        });
+        const xml = response.data;
+        const parser = new XMLParser({
+            ignoreAttributes: true,
+            trimValues: true,
+            parseTagValue: false,
+        });
+        const parsed = parser.parse(xml);
+        const channel = parsed?.rss?.channel;
+        if (!channel) {
+            return { items: [], error: 'RSS feed missing channel' };
+        }
+        const rawItems = ensureArray(channel.item);
+        let items = rawItems.map(parseItem);
+        if (statusFilter) {
+            items = items.filter((i) => i.status.toLowerCase() === statusFilter.toLowerCase());
+        }
+        if (apiFilter?.trim()) {
+            const needle = apiFilter.trim().toLowerCase();
+            items = items.filter((i) => i.api.toLowerCase().includes(needle));
+        }
+        items = items.slice(0, Math.min(limit, 50));
+        return { items };
+    }
+    catch (err) {
+        const message = axios.isAxiosError(err) && err.response?.status
+            ? `Feed unavailable (HTTP ${err.response.status})`
+            : err instanceof Error
+                ? err.message
+                : 'Failed to fetch API status feed';
+        return { items: [], error: message };
+    }
+}

package/build/utils/communication/feedback.js

@@ -0,0 +1,216 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Feedback API input validation
+ * Based on: src/api/communication/feedback.ts
+ * OpenAPI spec: docs/sell-apps/communication/commerce_feedback_v1_beta_oas3.json
+ * Types from: src/types/commerce_feedback_v1_beta_oas3.ts
+ */
+// Reusable schema for filter parameter
+const filterSchema = z
+    .string({
+    message: 'Filter must be a string',
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for the query',
+})
+    .optional();
+// Reusable schema for limit parameter (string in API, converted to number)
+const limitSchema = z
+    .string({
+    invalid_type_error: 'limit must be a string',
+    description: 'Maximum number of items to return per page (25-200)',
+})
+    .optional();
+// Reusable schema for offset parameter (string in API, converted to number)
+const offsetSchema = z
+    .string({
+    invalid_type_error: 'offset must be a string',
+    description: 'Number of items to skip',
+})
+    .optional();
+// Reusable schema for sort parameter
+const sortSchema = z
+    .string({
+    invalid_type_error: 'sort must be a string',
+    description: 'Sort order for results',
+})
+    .optional();
+/**
+ * Schema for getAwaitingFeedback method
+ * Endpoint: GET /awaiting_feedback
+ * Params: GetAwaitingFeedbackParams - filter, limit, offset, sort
+ */
+export const getAwaitingFeedbackSchema = z.object({
+    filter: filterSchema,
+    limit: limitSchema,
+    offset: offsetSchema,
+    sort: sortSchema,
+});
+/**
+ * Schema for getFeedback method
+ * Endpoint: GET /feedback
+ * Params: GetFeedbackParams - user_id (required), feedback_type (required), feedback_id, filter, limit, listing_id, offset, order_line_item_id, sort, transaction_id
+ */
+export const getFeedbackSchema = z.object({
+    user_id: z.string({
+        message: 'User ID is required',
+        required_error: 'user_id is required',
+        invalid_type_error: 'user_id must be a string',
+        description: 'The unique identifier (eBay username) of the user',
+    }),
+    feedback_type: z.string({
+        message: 'Feedback type is required',
+        required_error: 'feedback_type is required',
+        invalid_type_error: 'feedback_type must be a string',
+        description: 'Type of feedback (FEEDBACK_RECEIVED or FEEDBACK_SENT)',
+    }),
+    feedback_id: z
+        .string({
+        invalid_type_error: 'feedback_id must be a string',
+        description: 'Filter by specific feedback ID',
+    })
+        .optional(),
+    filter: filterSchema,
+    limit: limitSchema,
+    listing_id: z
+        .string({
+        invalid_type_error: 'listing_id must be a string',
+        description: 'Filter by listing ID',
+    })
+        .optional(),
+    offset: offsetSchema,
+    order_line_item_id: z
+        .string({
+        invalid_type_error: 'order_line_item_id must be a string',
+        description: 'Filter by order line item ID',
+    })
+        .optional(),
+    sort: sortSchema,
+    transaction_id: z
+        .string({
+        invalid_type_error: 'transaction_id must be a string',
+        description: 'Filter by transaction ID',
+    })
+        .optional(),
+});
+/**
+ * Schema for getFeedbackRatingSummary method
+ * Endpoint: GET /feedback_rating_summary
+ * Params: GetFeedbackRatingSummaryParams - user_id (required), filter (required)
+ */
+export const getFeedbackRatingSummarySchema = z.object({
+    user_id: z.string({
+        message: 'User ID is required',
+        required_error: 'user_id is required',
+        invalid_type_error: 'user_id must be a string',
+        description: 'The unique identifier of the eBay user',
+    }),
+    filter: z.string({
+        message: 'Filter is required (must include ratingType)',
+        required_error: 'filter is required',
+        invalid_type_error: 'filter must be a string',
+        description: 'Filter with required ratingType parameter',
+    }),
+});
+/**
+ * Schema for leaveFeedbackForBuyer method
+ * Endpoint: POST /feedback
+ * Body: LeaveFeedbackRequest - commentText, commentType, images, listingId, orderLineItemId, sellerRatings, transactionId
+ */
+export const leaveFeedbackForBuyerSchema = z.object({
+    comment_text: z
+        .string({
+        invalid_type_error: 'comment_text must be a string',
+        description: 'The feedback comment text (max 500 characters)',
+    })
+        .max(500, 'comment_text must be 500 characters or less')
+        .optional(),
+    comment_type: z
+        .string({
+        invalid_type_error: 'comment_type must be a string',
+        description: 'Overall rating: POSITIVE, NEUTRAL, or NEGATIVE',
+    })
+        .optional(),
+    images: z
+        .array(z.object({
+        url: z
+            .string({
+            invalid_type_error: 'image url must be a string',
+            description: 'URL of the image',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'images must be an array',
+        description: 'Array of up to 5 images',
+    })
+        .max(5, 'Maximum 5 images allowed')
+        .optional(),
+    listing_id: z
+        .string({
+        invalid_type_error: 'listing_id must be a string',
+        description: 'The listing ID related to the transaction',
+    })
+        .optional(),
+    order_line_item_id: z
+        .string({
+        invalid_type_error: 'order_line_item_id must be a string',
+        description: 'The unique identifier of the line item',
+    })
+        .optional(),
+    seller_ratings: z
+        .array(z.object({
+        key: z
+            .string({
+            invalid_type_error: 'seller rating key must be a string',
+            description: 'Rating category (e.g., ON_TIME_DELIVERY, ITEM_AS_DESCRIBED)',
+        })
+            .optional(),
+        value: z
+            .string({
+            invalid_type_error: 'seller rating value must be a string',
+            description: 'Rating value (1-5)',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'seller_ratings must be an array',
+        description: 'Array of seller performance ratings',
+    })
+        .optional(),
+    transaction_id: z
+        .string({
+        invalid_type_error: 'transaction_id must be a string',
+        description: 'The unique identifier of the transaction',
+    })
+        .optional(),
+});
+/**
+ * Schema for respondToFeedback method
+ * Endpoint: POST /respond_to_feedback
+ * Body: RespondToFeedbackRequest - feedbackId, recipientUserId, responseText, responseType
+ */
+export const respondToFeedbackSchema = z.object({
+    feedback_id: z
+        .string({
+        invalid_type_error: 'feedback_id must be a string',
+        description: 'The unique identifier of the feedback being responded to',
+    })
+        .optional(),
+    recipient_user_id: z
+        .string({
+        invalid_type_error: 'recipient_user_id must be a string',
+        description: 'The user ID of the feedback provider',
+    })
+        .optional(),
+    response_text: z
+        .string({
+        invalid_type_error: 'response_text must be a string',
+        description: 'The text content of the response (max 500 characters)',
+    })
+        .max(500, 'response_text must be 500 characters or less')
+        .optional(),
+    response_type: z
+        .string({
+        invalid_type_error: 'response_type must be a string',
+        description: 'The type of response: REPLY or FOLLOW_UP',
+    })
+        .optional(),
+});

package/build/utils/communication/message.js

@@ -0,0 +1,242 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Message API input validation
+ * Based on: src/api/communication/message.ts
+ * OpenAPI spec: docs/sell-apps/communication/commerce_message_v1_oas3.json
+ * Types from: src/types/commerce_message_v1_oas3.ts
+ */
+// Reusable schema for filter parameter
+const _filterSchema = z
+    .string({
+    message: 'Filter must be a string',
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for the query',
+})
+    .optional();
+// Reusable schema for limit parameter (string in API)
+const limitSchema = z
+    .string({
+    invalid_type_error: 'limit must be a string',
+    description: 'Maximum number of items to return (25-50)',
+})
+    .optional();
+// Reusable schema for offset parameter (string in API)
+const offsetSchema = z
+    .string({
+    invalid_type_error: 'offset must be a string',
+    description: 'Number of items to skip',
+})
+    .optional();
+/**
+ * Schema for bulkUpdateConversation method
+ * Endpoint: POST /bulk_update_conversation
+ * Body: BulkUpdateConversationsRequest - conversations array
+ */
+export const bulkUpdateConversationSchema = z.object({
+    conversations: z
+        .array(z.object({
+        conversation_id: z
+            .string({
+            invalid_type_error: 'conversation_id must be a string',
+            description: 'The unique identifier of the conversation',
+        })
+            .optional(),
+        conversation_status: z
+            .string({
+            invalid_type_error: 'conversation_status must be a string',
+            description: 'The updated status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
+        })
+            .optional(),
+        conversation_type: z
+            .string({
+            invalid_type_error: 'conversation_type must be a string',
+            description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'conversations must be an array',
+        description: 'Array of conversations to update',
+    })
+        .optional(),
+});
+/**
+ * Schema for getConversations method
+ * Endpoint: GET /conversation
+ * Params: GetConversationsParams - conversation_type (required), conversation_status, end_time, limit, offset, other_party_username, reference_id, reference_type, start_time
+ */
+export const getConversationsSchema = z.object({
+    conversation_type: z.string({
+        message: 'Conversation type is required',
+        required_error: 'conversation_type is required',
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'Type of conversation: FROM_EBAY or FROM_MEMBERS',
+    }),
+    conversation_status: z
+        .string({
+        invalid_type_error: 'conversation_status must be a string',
+        description: 'Filter by status: ACTIVE, ARCHIVE, DELETE, READ, UNREAD',
+    })
+        .optional(),
+    end_time: z
+        .string({
+        invalid_type_error: 'end_time must be a string',
+        description: 'End time for retrieving conversations (ISO 8601 format)',
+    })
+        .optional(),
+    limit: limitSchema,
+    offset: offsetSchema,
+    other_party_username: z
+        .string({
+        invalid_type_error: 'other_party_username must be a string',
+        description: 'Filter by specific eBay user',
+    })
+        .optional(),
+    reference_id: z
+        .string({
+        invalid_type_error: 'reference_id must be a string',
+        description: 'Filter by reference ID (e.g., listing ID)',
+    })
+        .optional(),
+    reference_type: z
+        .string({
+        invalid_type_error: 'reference_type must be a string',
+        description: 'Reference type (currently only LISTING is supported)',
+    })
+        .optional(),
+    start_time: z
+        .string({
+        invalid_type_error: 'start_time must be a string',
+        description: 'Start time for retrieving conversations (ISO 8601 format)',
+    })
+        .optional(),
+});
+/**
+ * Schema for getConversation method
+ * Endpoint: GET /conversation/{conversation_id}
+ * Path: conversation_id (required)
+ * Query: conversation_type (required), limit, offset
+ */
+export const getConversationSchema = z.object({
+    conversation_id: z.string({
+        message: 'Conversation ID is required',
+        required_error: 'conversation_id is required',
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'The unique identifier for the conversation',
+    }),
+    conversation_type: z.string({
+        message: 'Conversation type is required',
+        required_error: 'conversation_type is required',
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'Type of conversation: FROM_EBAY or FROM_MEMBERS',
+    }),
+    limit: limitSchema,
+    offset: offsetSchema,
+});
+/**
+ * Schema for sendMessage method
+ * Endpoint: POST /send_message
+ * Body: SendMessageRequest - conversationId, emailCopyToSender, messageMedia, messageText, otherPartyUsername, reference
+ */
+export const sendMessageSchema = z.object({
+    conversation_id: z
+        .string({
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'ID of existing conversation (required if sending in existing conversation)',
+    })
+        .optional(),
+    email_copy_to_sender: z
+        .boolean({
+        invalid_type_error: 'email_copy_to_sender must be a boolean',
+        description: 'Whether to email a copy to the sender',
+    })
+        .optional(),
+    message_media: z
+        .array(z.object({
+        media_name: z
+            .string({
+            invalid_type_error: 'media_name must be a string',
+            description: 'Name of the media',
+        })
+            .optional(),
+        media_type: z
+            .string({
+            invalid_type_error: 'media_type must be a string',
+            description: 'Type of media: IMAGE, PDF, DOC, TXT',
+        })
+            .optional(),
+        media_url: z
+            .string({
+            invalid_type_error: 'media_url must be a string',
+            description: 'HTTPS URL of the self-hosted media',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'message_media must be an array',
+        description: 'Array of up to 5 media attachments',
+    })
+        .max(5, 'Maximum 5 media attachments allowed')
+        .optional(),
+    message_text: z
+        .string({
+        invalid_type_error: 'message_text must be a string',
+        description: 'The text of the message (max 2000 characters)',
+    })
+        .max(2000, 'message_text must be 2000 characters or less')
+        .optional(),
+    other_party_username: z
+        .string({
+        invalid_type_error: 'other_party_username must be a string',
+        description: 'eBay username to send message to (required for new conversations)',
+    })
+        .optional(),
+    reference: z
+        .object({
+        reference_id: z
+            .string({
+            invalid_type_error: 'reference_id must be a string',
+            description: 'The reference ID (e.g., item ID for LISTING)',
+        })
+            .optional(),
+        reference_type: z
+            .string({
+            invalid_type_error: 'reference_type must be a string',
+            description: 'The reference type (currently only LISTING is supported)',
+        })
+            .optional(),
+    }, {
+        invalid_type_error: 'reference must be an object',
+        description: 'Reference to associate with the conversation',
+    })
+        .optional(),
+});
+/**
+ * Schema for updateConversation method
+ * Endpoint: POST /update_conversation
+ * Body: UpdateConversationRequest - conversationId, conversationStatus, conversationType, read
+ */
+export const updateConversationSchema = z.object({
+    conversation_id: z
+        .string({
+        invalid_type_error: 'conversation_id must be a string',
+        description: 'The unique identifier of the conversation',
+    })
+        .optional(),
+    conversation_status: z
+        .string({
+        invalid_type_error: 'conversation_status must be a string',
+        description: 'The updated status: ACTIVE, ARCHIVE, DELETE',
+    })
+        .optional(),
+    conversation_type: z
+        .string({
+        invalid_type_error: 'conversation_type must be a string',
+        description: 'The existing type: FROM_MEMBERS or FROM_EBAY (required but cannot be updated)',
+    })
+        .optional(),
+    read: z
+        .boolean({
+        invalid_type_error: 'read must be a boolean',
+        description: 'The read status to set (true = read, false = unread)',
+    })
+        .optional(),
+});

package/build/utils/communication/negotiation.js

@@ -0,0 +1,150 @@
+import { z } from 'zod';
+/**
+ * Zod schemas for Negotiation API input validation
+ * Based on: src/api/communication/negotiation.ts
+ * OpenAPI spec: docs/sell-apps/communication/sell_negotiation_v1_oas3.json
+ * Types from: src/types/sell_negotiation_v1_oas3.ts
+ */
+// Reusable schema for filter parameter
+const filterSchema = z
+    .string({
+    message: 'Filter must be a string',
+    invalid_type_error: 'filter must be a string',
+    description: 'Filter criteria for the query',
+})
+    .optional();
+// Reusable schema for limit parameter (string in API)
+const limitSchema = z
+    .string({
+    invalid_type_error: 'limit must be a string',
+    description: 'Maximum number of items to return (1-200)',
+})
+    .optional();
+// Reusable schema for offset parameter (string in API)
+const offsetSchema = z
+    .string({
+    invalid_type_error: 'offset must be a string',
+    description: 'Number of items to skip',
+})
+    .optional();
+/**
+ * Schema for findEligibleItems method
+ * Endpoint: GET /find_eligible_items
+ * Query Params: FindEligibleItemsParams - limit, offset
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export const findEligibleItemsSchema = z.object({
+    limit: limitSchema,
+    offset: offsetSchema,
+    marketplace_id: z
+        .string({
+        invalid_type_error: 'marketplace_id must be a string',
+        description: 'The eBay marketplace ID (X-EBAY-C-MARKETPLACE-ID header)',
+    })
+        .optional(),
+});
+/**
+ * Schema for sendOfferToInterestedBuyers method
+ * Endpoint: POST /send_offer_to_interested_buyers
+ * Body: CreateOffersRequest - allowCounterOffer, message, offerDuration, offeredItems
+ * Headers: X-EBAY-C-MARKETPLACE-ID (required)
+ */
+export const sendOfferToInterestedBuyersSchema = z.object({
+    allow_counter_offer: z
+        .boolean({
+        invalid_type_error: 'allow_counter_offer must be a boolean',
+        description: 'Whether to allow counter-offers (currently must be false)',
+    })
+        .optional(),
+    message: z
+        .string({
+        invalid_type_error: 'message must be a string',
+        description: 'Seller-defined message to buyers (max 2000 characters)',
+    })
+        .max(2000, 'message must be 2000 characters or less')
+        .optional(),
+    offer_duration: z
+        .object({
+        unit: z
+            .string({
+            invalid_type_error: 'unit must be a string',
+            description: 'Time unit (currently must be DAY)',
+        })
+            .optional(),
+        value: z
+            .number({
+            invalid_type_error: 'value must be a number',
+            description: 'Duration value (currently must be 2)',
+        })
+            .int({
+            message: 'value must be an integer',
+        })
+            .optional(),
+    }, {
+        invalid_type_error: 'offer_duration must be an object',
+        description: 'Duration the offer is valid (default: 2 days)',
+    })
+        .optional(),
+    offered_items: z
+        .array(z.object({
+        discount_percentage: z
+            .string({
+            invalid_type_error: 'discount_percentage must be a string',
+            description: 'Percentage discount (minimum 5)',
+        })
+            .optional(),
+        listing_id: z
+            .string({
+            invalid_type_error: 'listing_id must be a string',
+            description: 'The unique eBay listing ID',
+        })
+            .optional(),
+        price: z
+            .object({
+            currency: z
+                .string({
+                invalid_type_error: 'currency must be a string',
+                description: '3-letter ISO 4217 currency code',
+            })
+                .optional(),
+            value: z
+                .string({
+                invalid_type_error: 'value must be a string',
+                description: 'The monetary amount',
+            })
+                .optional(),
+        }, {
+            invalid_type_error: 'price must be an object',
+            description: 'The discounted price',
+        })
+            .optional(),
+        quantity: z
+            .number({
+            invalid_type_error: 'quantity must be a number',
+            description: 'Number of items (all-or-nothing offer)',
+        })
+            .int({
+            message: 'quantity must be an integer',
+        })
+            .optional(),
+    }), {
+        invalid_type_error: 'offered_items must be an array',
+        description: 'Array of items to offer (currently limited to one item)',
+    })
+        .optional(),
+    marketplace_id: z
+        .string({
+        invalid_type_error: 'marketplace_id must be a string',
+        description: 'The eBay marketplace ID (X-EBAY-C-MARKETPLACE-ID header)',
+    })
+        .optional(),
+});
+/**
+ * Schema for getOffersToBuyers method (deprecated)
+ * Note: This method does not match any endpoint in the OpenAPI spec
+ */
+export const getOffersToBuyersSchema = z.object({
+    filter: filterSchema,
+    limit: limitSchema,
+    offset: offsetSchema,
+});