ebay-mcp 1.13.2 → 1.14.0

package/build/utils/apiStatusFeed.js

@@ -0,0 +1,95 @@
+/**
+ * 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 { getErrorMessage } from '../utils/errors.js';
+import { httpRequestEffect, isHttpError } from './http.js';
+import { Effect, Either } from 'effect';
+const RSS_URL = 'https://developer.ebay.com/rss/api-status';
+const stripHtml = (html) => html
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+const 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 '';
+};
+const 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) || '',
+    };
+};
+/**
+ * Fetches the eBay API Status RSS feed, parses it, and returns items
+ * optionally filtered by status and API name, limited to `limit` items.
+ *
+ * @param options - Optional status/API filters and item limit.
+ * @returns An Effect that succeeds with parsed feed items or a recoverable error string.
+ *
+ * @example
+ * ```ts
+ * const feed = await Effect.runPromise(getApiStatusFeed({ status: 'Unresolved', limit: 10 }));
+ * ```
+ */
+export const getApiStatusFeed = (options = {}) => {
+    const { limit = 20, status: statusFilter, api: apiFilter } = options;
+    return Effect.either(httpRequestEffect({
+        url: RSS_URL,
+        timeoutMs: 15_000,
+        responseType: 'text',
+        headers: { Accept: 'application/rss+xml, application/xml, text/xml' },
+    }).pipe(Effect.flatMap((response) => Effect.try({
+        try: () => {
+            const parser = new XMLParser({
+                ignoreAttributes: true,
+                trimValues: true,
+                parseTagValue: false,
+            });
+            const parsed = parser.parse(response.data);
+            const channel = parsed?.rss?.channel;
+            if (!channel) {
+                return { items: [], error: 'RSS feed missing channel' };
+            }
+            let rawItems = [];
+            if (Array.isArray(channel.item)) {
+                rawItems = channel.item;
+            }
+            else if (channel.item) {
+                rawItems = [channel.item];
+            }
+            let items = rawItems.map(parseItem);
+            if (statusFilter) {
+                items = items.filter((item) => item.status.toLowerCase() === statusFilter.toLowerCase());
+            }
+            if (apiFilter?.trim()) {
+                const needle = apiFilter.trim().toLowerCase();
+                items = items.filter((item) => item.api.toLowerCase().includes(needle));
+            }
+            items = items.slice(0, Math.min(limit, 50));
+            return { items };
+        },
+        catch: (error) => error,
+    })))).pipe(Effect.map((parsedFeed) => {
+        if (Either.isLeft(parsedFeed)) {
+            const err = parsedFeed.left;
+            const message = isHttpError(err) && err.status
+                ? `Feed unavailable (HTTP ${err.status})`
+                : getErrorMessage(err, 'Failed to fetch API status feed');
+            return { items: [], error: message };
+        }
+        return parsedFeed.right;
+    }));
+};

package/build/utils/cliOutput.js

@@ -0,0 +1,15 @@
+import process from 'node:process';
+/**
+ * Writes one line to stdout for interactive CLI-only flows.
+ *
+ * @param message - Text to write before the trailing newline.
+ * @returns Nothing; writes to stdout.
+ *
+ * @example
+ * ```ts
+ * writeCliLine('Setup complete');
+ * ```
+ */
+export const writeCliLine = (message = '') => {
+    process.stdout.write(`${message}\n`);
+};

package/build/utils/cliUi.js

@@ -0,0 +1,108 @@
+import chalk from 'chalk';
+import { writeCliLine } from './cliOutput.js';
+/**
+ * Shared terminal styling for the project's interactive CLIs.
+ *
+ * These helpers print to stdout, which is correct for the setup/skills wizards
+ * (the stdout-is-reserved rule applies to the MCP *server* runtime, not CLI
+ * tooling). The eBay brand palette matches the setup wizard.
+ */
+export const ebayPalette = {
+    red: chalk.hex('#E53238'),
+    blue: chalk.hex('#0064D2'),
+    yellow: chalk.hex('#F5AF02'),
+    green: chalk.hex('#86B817'),
+};
+/** Semantic text styles used across CLI output. */
+export const ui = {
+    dim: chalk.dim,
+    bold: chalk.bold,
+    success: chalk.green,
+    warning: chalk.yellow,
+    error: chalk.red,
+    info: chalk.cyan,
+};
+/**
+ * Prints a green success line.
+ *
+ * @param message - Message to print after the status icon.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printSuccess('Configuration saved');
+ * ```
+ */
+export const printSuccess = (message) => {
+    writeCliLine(`  ${ui.success('✓')} ${message}`);
+};
+/**
+ * Prints a yellow warning line.
+ *
+ * @param message - Message to print after the status icon.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printWarning('No clients detected');
+ * ```
+ */
+export const printWarning = (message) => {
+    writeCliLine(`  ${ui.warning('⚠')} ${message}`);
+};
+/**
+ * Prints a red error line.
+ *
+ * @param message - Message to print after the status icon.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printError('Setup failed');
+ * ```
+ */
+export const printError = (message) => {
+    writeCliLine(`  ${ui.error('✗')} ${message}`);
+};
+/**
+ * Prints a cyan info line.
+ *
+ * @param message - Message to print after the status icon.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printInfo('Dry run - no files written');
+ * ```
+ */
+export const printInfo = (message) => {
+    writeCliLine(`  ${ui.info('ℹ')} ${message}`);
+};
+/**
+ * Prints a bold section heading preceded by a blank line.
+ *
+ * @param title - Heading text.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printHeading('Planned changes');
+ * ```
+ */
+export const printHeading = (title) => {
+    writeCliLine(`\n  ${ui.bold(title)}`);
+};
+/**
+ * Prints a dim horizontal rule.
+ *
+ * @param width - Number of rule characters to print.
+ * @returns Nothing; writes to stdout for interactive CLI flows.
+ *
+ * @example
+ * ```ts
+ * printRule(72);
+ * ```
+ */
+export const printRule = (width = 56) => {
+    writeCliLine('  ' + ui.dim('─'.repeat(width)));
+};

package/build/utils/communication/feedback.js

@@ -1,11 +1,9 @@
-import { z } from 'zod';
+import { z } from '../../utils/effectSchema.js';
 /**
- * Zod schemas for Feedback API input validation
- * Based on: src/api/communication/feedback.ts
+ * Effect-backed schemas for Feedback API input validation.
  * 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
+/** Optional feedback filter expression. */
 const filterSchema = z
     .string({
     message: 'Filter must be a string',
@@ -13,95 +11,85 @@ const filterSchema = z
     description: 'Filter criteria for the query',
 })
     .optional();
-// Reusable schema for limit parameter (string in API, converted to number)
+/** Optional positive page size accepted by Feedback list endpoints. */
 const limitSchema = z
-    .string({
-    invalid_type_error: 'limit must be a string',
+    .number({
+    invalid_type_error: 'limit must be a number',
     description: 'Maximum number of items to return per page (25-200)',
 })
+    .positive('limit must be a positive number')
     .optional();
-// Reusable schema for offset parameter (string in API, converted to number)
+/** Optional zero-based page offset accepted by Feedback list endpoints. */
 const offsetSchema = z
-    .string({
-    invalid_type_error: 'offset must be a string',
+    .number({
+    invalid_type_error: 'offset must be a number',
     description: 'Number of items to skip',
 })
+    .min(0, 'offset must be a non-negative number')
     .optional();
-// Reusable schema for sort parameter
+/** Optional feedback result sort order. */
 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
- */
+/** Schema for getAwaitingFeedback input. */
 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
- */
+/** Schema for getFeedback input. */
 export const getFeedbackSchema = z.object({
-    user_id: z.string({
+    userId: z.string({
         message: 'User ID is required',
-        required_error: 'user_id is required',
-        invalid_type_error: 'user_id must be a string',
+        required_error: 'userId is required',
+        invalid_type_error: 'userId must be a string',
         description: 'The unique identifier (eBay username) of the user',
     }),
-    feedback_type: z.string({
+    feedbackType: z.string({
         message: 'Feedback type is required',
-        required_error: 'feedback_type is required',
-        invalid_type_error: 'feedback_type must be a string',
+        required_error: 'feedbackType is required',
+        invalid_type_error: 'feedbackType must be a string',
         description: 'Type of feedback (FEEDBACK_RECEIVED or FEEDBACK_SENT)',
     }),
-    feedback_id: z
+    feedbackId: z
         .string({
-        invalid_type_error: 'feedback_id must be a string',
+        invalid_type_error: 'feedbackId must be a string',
         description: 'Filter by specific feedback ID',
     })
         .optional(),
     filter: filterSchema,
     limit: limitSchema,
-    listing_id: z
+    listingId: z
         .string({
-        invalid_type_error: 'listing_id must be a string',
+        invalid_type_error: 'listingId must be a string',
         description: 'Filter by listing ID',
     })
         .optional(),
     offset: offsetSchema,
-    order_line_item_id: z
+    orderLineItemId: z
         .string({
-        invalid_type_error: 'order_line_item_id must be a string',
+        invalid_type_error: 'orderLineItemId must be a string',
         description: 'Filter by order line item ID',
     })
         .optional(),
     sort: sortSchema,
-    transaction_id: z
+    transactionId: z
         .string({
-        invalid_type_error: 'transaction_id must be a string',
-        description: 'Filter by transaction ID',
+        invalid_type_error: 'transactionId must be a string',
+        description: 'The unique identifier of the transaction',
     })
         .optional(),
 });
-/**
- * Schema for getFeedbackRatingSummary method
- * Endpoint: GET /feedback_rating_summary
- * Params: GetFeedbackRatingSummaryParams - user_id (required), filter (required)
- */
+/** Schema for getFeedbackRatingSummary input. */
 export const getFeedbackRatingSummarySchema = z.object({
-    user_id: z.string({
+    userId: z.string({
         message: 'User ID is required',
-        required_error: 'user_id is required',
-        invalid_type_error: 'user_id must be a string',
+        required_error: 'userId is required',
+        invalid_type_error: 'userId must be a string',
         description: 'The unique identifier of the eBay user',
     }),
     filter: z.string({
@@ -111,22 +99,18 @@ export const getFeedbackRatingSummarySchema = z.object({
         description: 'Filter with required ratingType parameter',
     }),
 });
-/**
- * Schema for leaveFeedbackForBuyer method
- * Endpoint: POST /feedback
- * Body: LeaveFeedbackRequest - commentText, commentType, images, listingId, orderLineItemId, sellerRatings, transactionId
- */
+/** Schema for leaveFeedback input. */
 export const leaveFeedbackForBuyerSchema = z.object({
-    comment_text: z
+    commentText: z
         .string({
-        invalid_type_error: 'comment_text must be a string',
+        invalid_type_error: 'commentText must be a string',
         description: 'The feedback comment text (max 500 characters)',
     })
-        .max(500, 'comment_text must be 500 characters or less')
+        .max(500, 'commentText must be 500 characters or less')
         .optional(),
-    comment_type: z
+    commentType: z
         .string({
-        invalid_type_error: 'comment_type must be a string',
+        invalid_type_error: 'commentType must be a string',
         description: 'Overall rating: POSITIVE, NEUTRAL, or NEGATIVE',
     })
         .optional(),
@@ -144,19 +128,19 @@ export const leaveFeedbackForBuyerSchema = z.object({
     })
         .max(5, 'Maximum 5 images allowed')
         .optional(),
-    listing_id: z
+    listingId: z
         .string({
-        invalid_type_error: 'listing_id must be a string',
+        invalid_type_error: 'listingId must be a string',
         description: 'The listing ID related to the transaction',
     })
         .optional(),
-    order_line_item_id: z
+    orderLineItemId: z
         .string({
-        invalid_type_error: 'order_line_item_id must be a string',
+        invalid_type_error: 'orderLineItemId must be a string',
         description: 'The unique identifier of the line item',
     })
         .optional(),
-    seller_ratings: z
+    sellerRatings: z
         .array(z.object({
         key: z
             .string({
@@ -171,45 +155,41 @@ export const leaveFeedbackForBuyerSchema = z.object({
         })
             .optional(),
     }), {
-        invalid_type_error: 'seller_ratings must be an array',
+        invalid_type_error: 'sellerRatings must be an array',
         description: 'Array of seller performance ratings',
     })
         .optional(),
-    transaction_id: z
+    transactionId: z
         .string({
-        invalid_type_error: 'transaction_id must be a string',
+        invalid_type_error: 'transactionId 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
- */
+/** Schema for respondToFeedback input. */
 export const respondToFeedbackSchema = z.object({
-    feedback_id: z
+    feedbackId: z
         .string({
-        invalid_type_error: 'feedback_id must be a string',
+        invalid_type_error: 'feedbackId must be a string',
         description: 'The unique identifier of the feedback being responded to',
     })
         .optional(),
-    recipient_user_id: z
+    recipientUserId: z
         .string({
-        invalid_type_error: 'recipient_user_id must be a string',
+        invalid_type_error: 'recipientUserId must be a string',
         description: 'The user ID of the feedback provider',
     })
         .optional(),
-    response_text: z
+    responseText: z
         .string({
-        invalid_type_error: 'response_text must be a string',
+        invalid_type_error: 'responseText must be a string',
         description: 'The text content of the response (max 500 characters)',
     })
-        .max(500, 'response_text must be 500 characters or less')
+        .max(500, 'responseText must be 500 characters or less')
         .optional(),
-    response_type: z
+    responseType: z
         .string({
-        invalid_type_error: 'response_type must be a string',
+        invalid_type_error: 'responseType must be a string',
         description: 'The type of response: REPLY or FOLLOW_UP',
     })
         .optional(),