ebay-mcp 1.18.0 → 1.18.2

package/build/api/shared/download.js

@@ -43,7 +43,7 @@ export class DownloadTooLargeError extends Data.TaggedError('DownloadTooLargeErr
     }
 }
 /** Size of a download: what was read, or the larger declared length when reading stopped early. */
-const downloadSize = (response) => Math.max(response.data.length, Number(response.headers['content-length']) || 0);
+const downloadSize = (fileResponse) => Math.max(fileResponse.data.length, Number(fileResponse.headers['content-length']) || 0);
 /**
  * Downloads a binary eBay resource as an Effect, keeping its content type and file name.
  * Reading stops as soon as the file is known to exceed {@link MAX_INLINE_DOWNLOAD_BYTES}.
@@ -68,12 +68,12 @@ export const requestDownloadEffect = (client, path, config = {}) => Effect.tryPr
         maxBytes: MAX_INLINE_DOWNLOAD_BYTES,
     }),
     catch: (cause) => new EbayApiError({ method: 'GET', path, cause }), // allow-duplicate
-}).pipe(Effect.filterOrFail((response) => downloadSize(response) <= MAX_INLINE_DOWNLOAD_BYTES, (response) => new DownloadTooLargeError({
+}).pipe(Effect.filterOrFail((fileResponse) => downloadSize(fileResponse) <= MAX_INLINE_DOWNLOAD_BYTES, (fileResponse) => new DownloadTooLargeError({
     path,
-    bytes: downloadSize(response),
+    bytes: downloadSize(fileResponse),
     limit: MAX_INLINE_DOWNLOAD_BYTES,
-})), Effect.map((response) => ({
-    bytes: response.data,
-    contentType: response.headers['content-type']?.split(';')[0]?.trim() || DEFAULT_CONTENT_TYPE,
-    fileName: fileNameFromDisposition(response.headers['content-disposition']),
+})), Effect.map((fileResponse) => ({
+    bytes: fileResponse.data,
+    contentType: fileResponse.headers['content-type']?.split(';')[0]?.trim() || DEFAULT_CONTENT_TYPE,
+    fileName: fileNameFromDisposition(fileResponse.headers['content-disposition']),
 })));

package/build/api/shared/request.js

@@ -1,4 +1,4 @@
-import { decodeEffectSchema } from '../../utils/effectSchema.js';
+import { formatZodIssues } from '../../utils/zodIssues.js';
 import { Data, Effect } from 'effect';
 /** Tagged failure returned by migrated eBay API endpoint Effects. */
 export class EbayApiError extends Data.TaggedError('EbayApiError') {
@@ -11,10 +11,10 @@ export class EbayApiError extends Data.TaggedError('EbayApiError') {
 export class EndpointInputError extends Data.TaggedError('EndpointInputError') {
 }
 /**
- * Decodes endpoint input through its Effect-backed schema (the tool's SSOT), reporting a
+ * Parses endpoint input through its Zod schema (the tool's SSOT), reporting a
  * failure as EndpointInputError so endpoint Effects keep one input-failure type.
  *
- * @param schema - Effect-backed endpoint input schema.
+ * @param schema - Zod endpoint input schema.
  * @param input - Raw endpoint input.
  * @param parameter - Parameter named in the failure; defaults to `input`.
  * @returns An Effect with the decoded input, or EndpointInputError.
@@ -24,7 +24,12 @@ export class EndpointInputError extends Data.TaggedError('EndpointInputError') {
  * const { documentId } = yield* decodeEndpointInputEffect(documentIdInputSchema, input);
  * ```
  */
-export const decodeEndpointInputEffect = (schema, input, parameter = 'input') => decodeEffectSchema(schema, input).pipe(Effect.mapError((cause) => new EndpointInputError({ parameter, message: cause.message })));
+export const decodeEndpointInputEffect = (schema, input, parameter = 'input') => {
+    const parsedInput = schema.safeParse(input);
+    return parsedInput.success
+        ? Effect.succeed(parsedInput.data)
+        : Effect.fail(new EndpointInputError({ parameter, message: formatZodIssues(parsedInput.error) }));
+};
 /**
  * Builds the per-call `X-EBAY-C-MARKETPLACE-ID` header for operations whose marketplace
  * differs from the client's configured `EBAY_MARKETPLACE_ID`.
@@ -164,7 +169,7 @@ export const optionalNonNegativeNumberEffect = (value, name) => {
  *
  * @example
  * ```ts
- * const request = yield* requireObjectEffect<CreateOffersRequest>(body, 'offerData');
+ * const createOffersRequest = yield* requireObjectEffect<CreateOffersRequest>(offerData, 'offerData');
  * ```
  */
 export const requireObjectEffect = (value, name) => {
@@ -187,7 +192,7 @@ export const requireObjectEffect = (value, name) => {
  *
  * @example
  * ```ts
- * const response = await Effect.runPromise(requestGetEffect(client, path, params));
+ * const policies = await Effect.runPromise(requestGetEffect(client, path, params));
  * ```
  */
 export const requestGetEffect = (client, path, params, config) => Effect.tryPromise({
@@ -204,21 +209,21 @@ export const requestGetEffect = (client, path, params, config) => Effect.tryProm
  *
  * @param client - eBay REST client that owns auth and transport details.
  * @param path - eBay REST path to request.
- * @param body - Optional JSON body to send.
+ * @param requestBody - Optional JSON body to send.
  * @param config - Optional per-request headers or params, used for endpoint-specific headers.
  * @returns An Effect that succeeds with the generated eBay response DTO.
  *
  * @example
  * ```ts
- * const response = await Effect.runPromise(requestPostEffect(client, path, body));
+ * const createdPolicy = await Effect.runPromise(requestPostEffect(client, path, requestBody));
  * ```
  */
-export const requestPostEffect = (client, path, body, config) => Effect.tryPromise({
+export const requestPostEffect = (client, path, requestBody, config) => Effect.tryPromise({
     try: () => {
         if (config !== undefined) {
-            return client.post(path, body, config);
+            return client.post(path, requestBody, config);
         }
-        return body === undefined ? client.post(path) : client.post(path, body);
+        return requestBody === undefined ? client.post(path) : client.post(path, requestBody);
     },
     catch: (cause) => new EbayApiError({ method: 'POST', path, cause }),
 });
@@ -227,16 +232,18 @@ export const requestPostEffect = (client, path, body, config) => Effect.tryPromi
  *
  * @param client - eBay REST client that owns auth and transport details.
  * @param path - eBay REST path to request.
- * @param body - Optional JSON body to send.
+ * @param requestBody - Optional JSON body to send.
  * @returns An Effect that succeeds with the generated eBay response DTO.
  *
  * @example
  * ```ts
- * const response = await Effect.runPromise(requestPutEffect(client, path, body));
+ * const updatedPolicy = await Effect.runPromise(requestPutEffect(client, path, requestBody));
  * ```
  */
-export const requestPutEffect = (client, path, body, config) => Effect.tryPromise({
-    try: () => config === undefined ? client.put(path, body) : client.put(path, body, config),
+export const requestPutEffect = (client, path, requestBody, config) => Effect.tryPromise({
+    try: () => config === undefined
+        ? client.put(path, requestBody)
+        : client.put(path, requestBody, config),
     catch: (cause) => new EbayApiError({ method: 'PUT', path, cause }),
 });
 /**
@@ -244,17 +251,19 @@ export const requestPutEffect = (client, path, body, config) => Effect.tryPromis
  *
  * @param client - eBay REST client that owns auth and transport details.
  * @param path - eBay REST path to request.
- * @param body - Optional JSON body to send.
+ * @param requestBody - Optional JSON body to send.
  * @param config - Optional per-request headers or params, used for endpoint-specific headers.
  * @returns An Effect that succeeds with the generated eBay response DTO.
  *
  * @example
  * ```ts
- * await Effect.runPromise(requestPatchEffect(client, path, body, { headers }));
+ * await Effect.runPromise(requestPatchEffect(client, path, requestBody, { headers }));
  * ```
  */
-export const requestPatchEffect = (client, path, body, config) => Effect.tryPromise({
-    try: () => config === undefined ? client.patch(path, body) : client.patch(path, body, config),
+export const requestPatchEffect = (client, path, requestBody, config) => Effect.tryPromise({
+    try: () => config === undefined
+        ? client.patch(path, requestBody)
+        : client.patch(path, requestBody, config),
     catch: (cause) => new EbayApiError({ method: 'PATCH', path, cause }),
 });
 /**

package/build/api/trading/listingFormat.js

@@ -21,68 +21,70 @@ const inputError = (parameter, message) => new EndpointInputError({ parameter, m
  * Reads a Trading amount, which callers may pass as a bare number, a numeric
  * string, or an attributed XML node such as `{ '#text': 9.99, '@_currencyID': 'USD' }`.
  */
-const parseTradingAmount = (value) => {
-    const raw = isRecord(value) ? value['#text'] : value;
-    if (raw === undefined || raw === null || raw === '') {
+const parseTradingAmount = (rawAmount) => {
+    const amount = isRecord(rawAmount) ? rawAmount['#text'] : rawAmount;
+    if (amount === undefined || amount === null || amount === '') {
         return;
     }
-    const parsed = Number(raw);
+    const parsed = Number(amount);
     return Number.isFinite(parsed) ? parsed : undefined;
 };
-const isBestOfferEnabled = (item) => {
-    const details = item.BestOfferDetails;
+const isBestOfferEnabled = (tradingItem) => {
+    const details = tradingItem.BestOfferDetails;
     if (!isRecord(details)) {
         return false;
     }
     return details.BestOfferEnabled === true || details.BestOfferEnabled === 'true';
 };
-const auctionViolation = (item, parameter) => {
-    if (item.ListingType !== undefined && item.ListingType !== TRADING_AUCTION_LISTING_TYPE) {
-        return inputError(`${parameter}.ListingType`, `AUCTION listings use ListingType ${TRADING_AUCTION_LISTING_TYPE}; omit it or pass format FIXED_PRICE for ${String(item.ListingType)}`);
+const auctionViolation = (tradingItem, parameter) => {
+    if (tradingItem.ListingType !== undefined &&
+        tradingItem.ListingType !== TRADING_AUCTION_LISTING_TYPE) {
+        return inputError(`${parameter}.ListingType`, `AUCTION listings use ListingType ${TRADING_AUCTION_LISTING_TYPE}; omit it or pass format FIXED_PRICE for ${String(tradingItem.ListingType)}`);
     }
-    if (item.ListingDuration === TRADING_GTC_DURATION) {
+    if (tradingItem.ListingDuration === TRADING_GTC_DURATION) {
         return inputError(`${parameter}.ListingDuration`, 'AUCTION listings need a day-count ListingDuration such as Days_7; GTC is only valid for FIXED_PRICE listings');
     }
-    if (item.Quantity !== undefined && Number(item.Quantity) !== 1) {
+    if (tradingItem.Quantity !== undefined && Number(tradingItem.Quantity) !== 1) {
         return inputError(`${parameter}.Quantity`, 'AUCTION listings sell a single unit; omit Quantity or set it to 1');
     }
-    if (isBestOfferEnabled(item) && item.BuyItNowPrice !== undefined) {
+    if (isBestOfferEnabled(tradingItem) && tradingItem.BuyItNowPrice !== undefined) {
         return inputError(`${parameter}.BestOfferDetails.BestOfferEnabled`, 'an AUCTION listing can carry Best Offer or a BuyItNowPrice, not both');
     }
 };
 /** Fields eBay requires when an auction is created with AddItem. */
-const auctionCreateViolation = (item, parameter) => {
-    if (item.ListingDuration === undefined) {
+const auctionCreateViolation = (tradingItem, parameter) => {
+    if (tradingItem.ListingDuration === undefined) {
         return inputError(`${parameter}.ListingDuration`, 'ListingDuration is required for AUCTION listings (a day count such as Days_7)');
     }
-    if (parseTradingAmount(item.StartPrice) === undefined) {
+    if (parseTradingAmount(tradingItem.StartPrice) === undefined) {
         return inputError(`${parameter}.StartPrice`, 'StartPrice (the opening bid) is required for AUCTION listings');
     }
 };
-const fixedPriceViolation = (item, parameter) => {
-    if (item.ListingType === TRADING_AUCTION_LISTING_TYPE) {
+const fixedPriceViolation = (tradingItem, parameter) => {
+    if (tradingItem.ListingType === TRADING_AUCTION_LISTING_TYPE) {
         return inputError(`${parameter}.ListingType`, `ListingType ${TRADING_AUCTION_LISTING_TYPE} is an auction; pass format AUCTION instead`);
     }
-    if (item.ListingDuration !== undefined && item.ListingDuration !== TRADING_GTC_DURATION) {
+    if (tradingItem.ListingDuration !== undefined &&
+        tradingItem.ListingDuration !== TRADING_GTC_DURATION) {
         return inputError(`${parameter}.ListingDuration`, `FIXED_PRICE listings must use ListingDuration ${TRADING_GTC_DURATION} (the only duration eBay accepts for fixed-price listings); day counts such as Days_7 are for AUCTION listings`);
     }
-    if (item.ReservePrice !== undefined) {
+    if (tradingItem.ReservePrice !== undefined) {
         return inputError(`${parameter}.ReservePrice`, 'ReservePrice only applies to AUCTION listings');
     }
-    if (item.BuyItNowPrice !== undefined) {
+    if (tradingItem.BuyItNowPrice !== undefined) {
         return inputError(`${parameter}.BuyItNowPrice`, 'BuyItNowPrice only applies to AUCTION listings; FIXED_PRICE listings use StartPrice');
     }
 };
-const auctionPriceViolation = (item, parameter) => {
-    const start = parseTradingAmount(item.StartPrice);
+const auctionPriceViolation = (tradingItem, parameter) => {
+    const start = parseTradingAmount(tradingItem.StartPrice);
     if (start === undefined) {
         return;
     }
-    const reserve = parseTradingAmount(item.ReservePrice);
+    const reserve = parseTradingAmount(tradingItem.ReservePrice);
     if (reserve !== undefined && reserve <= start) {
         return inputError(`${parameter}.ReservePrice`, 'ReservePrice must be higher than StartPrice (the opening bid)');
     }
-    const buyItNow = parseTradingAmount(item.BuyItNowPrice);
+    const buyItNow = parseTradingAmount(tradingItem.BuyItNowPrice);
     if (buyItNow !== undefined && !meetsBuyItNowMargin(start, buyItNow)) {
         return inputError(`${parameter}.BuyItNowPrice`, `BuyItNowPrice must be at least ${BUY_IT_NOW_MARGIN_LABEL} higher than StartPrice (the opening bid)`);
     }
@@ -110,13 +112,13 @@ const auctionPriceViolation = (item, parameter) => {
  * });
  * ```
  */
-export const findTradingListingFormatViolation = ({ item, format, parameter, isCreate, }) => {
+export const findTradingListingFormatViolation = ({ item: tradingItem, format, parameter, isCreate, }) => {
     if (format === FormatType.FIXED_PRICE) {
-        return fixedPriceViolation(item, parameter);
+        return fixedPriceViolation(tradingItem, parameter);
     }
-    return (auctionViolation(item, parameter) ??
-        (isCreate ? auctionCreateViolation(item, parameter) : undefined) ??
-        auctionPriceViolation(item, parameter));
+    return (auctionViolation(tradingItem, parameter) ??
+        (isCreate ? auctionCreateViolation(tradingItem, parameter) : undefined) ??
+        auctionPriceViolation(tradingItem, parameter));
 };
 /**
  * Rejects a Trading `Item` payload that mixes AUCTION and FIXED_PRICE fields before it reaches eBay.
@@ -126,7 +128,12 @@ export const findTradingListingFormatViolation = ({ item, format, parameter, isC
  *
  * @example
  * ```ts
- * yield* validateTradingListingFormatEffect({ item, format, parameter: 'item', isCreate: true });
+ * yield* validateTradingListingFormatEffect({
+ *   item: tradingItem,
+ *   format,
+ *   parameter: 'item',
+ *   isCreate: true,
+ * });
  * ```
  */
 export const validateTradingListingFormatEffect = (check) => {

package/build/api/trading/trading.js

@@ -3,11 +3,11 @@ import { FormatType } from '../../types/ebayEnums.js';
 import { isRecord } from '../../utils/typeGuards.js';
 import { Effect } from 'effect';
 import { TRADING_AUCTION_LISTING_TYPE, resolveTradingFormat, tradingCallName, validateTradingEndingReasonEffect, validateTradingListingFormatEffect, } from './listingFormat.js';
-const asRecordArray = (value) => {
-    if (!Array.isArray(value)) {
+const asRecordArray = (rawField) => {
+    if (!Array.isArray(rawField)) {
         return [];
     }
-    return value.filter(isRecord);
+    return rawField.filter(isRecord);
 };
 /**
  * High-level wrapper for seller listing operations backed by eBay Trading API calls.
@@ -25,7 +25,7 @@ export class TradingApi {
      *
      * @example
      * ```ts
-     * const response = await Effect.runPromise(
+     * const tradingRecord = await Effect.runPromise(
      *   tradingApi.getActiveListings({ page: 2, entriesPerPage: 25 }),
      * );
      * ```
@@ -35,9 +35,9 @@ export class TradingApi {
     getActiveListings = (input = {}) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const inputPage = yield* optionalPositiveNumberEffect(request.page, 'page');
-            const inputEntriesPerPage = yield* optionalPositiveNumberEffect(request.entriesPerPage, 'entriesPerPage');
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const inputPage = yield* optionalPositiveNumberEffect(validatedInput.page, 'page');
+            const inputEntriesPerPage = yield* optionalPositiveNumberEffect(validatedInput.entriesPerPage, 'entriesPerPage');
             const page = inputPage === undefined ? 1 : inputPage;
             const entriesPerPage = inputEntriesPerPage === undefined ? 50 : inputEntriesPerPage;
             return yield* tradingClient.execute('GetMyeBaySelling', {
@@ -67,14 +67,14 @@ export class TradingApi {
     getListing = (input) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const itemId = yield* requireStringEffect(request.itemId, 'itemId');
-            const result = yield* tradingClient.execute('GetItem', {
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const itemId = yield* requireStringEffect(validatedInput.itemId, 'itemId');
+            const getItemResponse = yield* tradingClient.execute('GetItem', {
                 ItemID: itemId,
                 DetailLevel: 'ReturnAll',
             });
-            const items = asRecordArray(result.Item);
-            return items.length > 0 ? items[0] : result;
+            const items = asRecordArray(getItemResponse.Item);
+            return items.length > 0 ? items[0] : getItemResponse;
         });
     };
     /**
@@ -105,19 +105,19 @@ export class TradingApi {
     createListing = (input) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const format = resolveTradingFormat(request.format);
-            const item = yield* requireObjectEffect(request.item, 'item');
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const format = resolveTradingFormat(validatedInput.format);
+            const tradingItem = yield* requireObjectEffect(validatedInput.item, 'item');
             yield* validateTradingListingFormatEffect({
-                item,
+                item: tradingItem,
                 format,
                 parameter: 'item',
                 isCreate: true,
             });
-            const payload = format === FormatType.AUCTION
-                ? { ...item, ListingType: TRADING_AUCTION_LISTING_TYPE }
-                : item;
-            return yield* tradingClient.execute(tradingCallName('create', format), { Item: payload });
+            const listingItem = format === FormatType.AUCTION
+                ? { ...tradingItem, ListingType: TRADING_AUCTION_LISTING_TYPE }
+                : tradingItem;
+            return yield* tradingClient.execute(tradingCallName('create', format), { Item: listingItem });
         });
     };
     /**
@@ -142,10 +142,10 @@ export class TradingApi {
     reviseListing = (input) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const format = resolveTradingFormat(request.format);
-            const itemId = yield* requireStringEffect(request.itemId, 'itemId');
-            const fields = yield* requireObjectEffect(request.fields, 'fields');
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const format = resolveTradingFormat(validatedInput.format);
+            const itemId = yield* requireStringEffect(validatedInput.itemId, 'itemId');
+            const fields = yield* requireObjectEffect(validatedInput.fields, 'fields');
             yield* validateTradingListingFormatEffect({
                 item: fields,
                 format,
@@ -179,10 +179,10 @@ export class TradingApi {
     endListing = (input) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const format = resolveTradingFormat(request.format);
-            const itemId = yield* requireStringEffect(request.itemId, 'itemId');
-            const inputReason = yield* optionalStringEffect(request.reason, 'reason');
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const format = resolveTradingFormat(validatedInput.format);
+            const itemId = yield* requireStringEffect(validatedInput.itemId, 'itemId');
+            const inputReason = yield* optionalStringEffect(validatedInput.reason, 'reason');
             yield* validateTradingEndingReasonEffect(inputReason, format, 'reason');
             const reason = inputReason === undefined ? 'NotAvailable' : inputReason;
             return yield* tradingClient.execute(tradingCallName('end', format), {
@@ -213,12 +213,12 @@ export class TradingApi {
     relistItem = (input) => {
         const tradingClient = this.client;
         return Effect.gen(function* () {
-            const request = yield* requireObjectEffect(input, 'input');
-            const format = resolveTradingFormat(request.format);
-            const itemId = yield* requireStringEffect(request.itemId, 'itemId');
+            const validatedInput = yield* requireObjectEffect(input, 'input');
+            const format = resolveTradingFormat(validatedInput.format);
+            const itemId = yield* requireStringEffect(validatedInput.itemId, 'itemId');
             let modifications = {};
-            if (request.modifications !== undefined) {
-                modifications = yield* requireObjectEffect(request.modifications, 'modifications');
+            if (validatedInput.modifications !== undefined) {
+                modifications = yield* requireObjectEffect(validatedInput.modifications, 'modifications');
             }
             yield* validateTradingListingFormatEffect({
                 item: modifications,

package/build/auth/credentialSession.js

@@ -1,7 +1,7 @@
 import dotenv from 'dotenv';
-import stringify from 'dotenv-stringify';
 import { closeSync, existsSync, fsyncSync, openSync, readFileSync, writeFileSync } from 'fs';
 import { CREDENTIAL_ENV_PATH } from '../config/credentialFile.js';
+import { stringifyEnv } from '../utils/envFile.js';
 import { Data, Effect } from 'effect';
 /**
  * Default lifetime for stored eBay user access tokens when eBay omits an expiry.
@@ -66,15 +66,15 @@ export class DotEnvCredentialStore {
             try: () => {
                 // Drop non-string values so a missing refresh_token cannot persist as empty.
                 const sanitizedUpdates = {};
-                for (const [key, value] of Object.entries(updates)) {
-                    if (typeof value === 'string') {
-                        sanitizedUpdates[key] = value;
+                for (const [name, envValue] of Object.entries(updates)) {
+                    if (typeof envValue === 'string') {
+                        sanitizedUpdates[name] = envValue;
                     }
                 }
                 const existingEnv = existsSync(envPath)
                     ? dotenv.parse(readFileSync(envPath, 'utf-8'))
                     : {};
-                const safeEnvContent = stringify({ ...existingEnv, ...sanitizedUpdates });
+                const safeEnvContent = stringifyEnv({ ...existingEnv, ...sanitizedUpdates });
                 writeFileSync(envPath, safeEnvContent, 'utf-8');
                 // Durability: best-effort fsync. Windows and mocked FS may reject fsync
                 // on a read-only open; never fail the write after a successful writeFileSync.

package/build/auth/oauth.js

@@ -415,7 +415,7 @@ export class EbayOAuthClient {
      * ```
      */
     getTokenInfo() {
-        const info = {
+        const tokenInfo = {
             hasUserToken: this.userTokens !== null && !this.isUserAccessTokenExpired(this.userTokens),
             hasAppAccessToken: this.appAccessToken !== null && Date.now() < this.appAccessTokenExpiry,
         };
@@ -426,7 +426,7 @@ export class EbayOAuthClient {
             const tokenScopeSet = new Set(tokenScopes);
             const missingScopes = environmentScopes.filter((scope) => !tokenScopeSet.has(scope));
             return {
-                ...info,
+                ...tokenInfo,
                 scopeInfo: {
                     tokenScopes,
                     environmentScopes,
@@ -434,7 +434,7 @@ export class EbayOAuthClient {
                 },
             };
         }
-        return info;
+        return tokenInfo;
     }
     /**
      * Get internal user tokens for debugging and status tools.

package/build/auth/oauthHelper.js

@@ -32,7 +32,7 @@ export const generateAuthUrl = (clientId, redirectUri, environment, scopes) => g
  * HTML-significant characters neutralizes the markup while keeping the message
  * legible.
  */
-const escapeHtml = (value) => value
+const escapeHtml = (text) => text
     .replace(/&/g, '&')
     .replace(/</g, '&lt;')
     .replace(/>/g, '&gt;')
@@ -107,24 +107,24 @@ const renderCallbackPage = (success, detail = '') => {
 export const startCallbackServer = async (port = 3000, timeoutMs = 300_000, options = {}) => {
     const callbackPath = options.path ?? '/oauth/callback';
     const { expectedState } = options;
-    return await new Promise((resolve, reject) => {
+    return await new Promise((onServerReady, onServerError) => {
         let timer;
         let settled = false;
         let settle;
         const codePromise = new Promise((resolveCode) => {
-            settle = (result) => {
+            settle = (outcome) => {
                 if (settled)
                     return;
                 settled = true;
                 clearTimeout(timer);
-                resolveCode(result);
+                resolveCode(outcome);
             };
         });
-        const server = createServer((req, res) => {
-            const url = new URL(req.url ?? '/', `http://localhost:${port}`);
+        const server = createServer((request, response) => {
+            const url = new URL(request.url ?? '/', `http://localhost:${port}`);
             if (url.pathname !== callbackPath) {
-                res.writeHead(404);
-                res.end('Not Found');
+                response.writeHead(404);
+                response.end('Not Found');
                 return;
             }
             const code = url.searchParams.get('code') ?? undefined;
@@ -132,8 +132,8 @@ export const startCallbackServer = async (port = 3000, timeoutMs = 300_000, opti
             const error = url.searchParams.get('error') ?? undefined;
             const errorDescription = url.searchParams.get('error_description') ?? undefined;
             if (expectedState && state !== expectedState) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(renderCallbackPage(false, 'State mismatch — the request may have been tampered with.'));
+                response.writeHead(400, { 'Content-Type': 'text/html' });
+                response.end(renderCallbackPage(false, 'State mismatch — the request may have been tampered with.'));
                 settle({
                     error: 'invalid_state',
                     errorDescription: 'State parameter mismatch — possible CSRF.',
@@ -141,23 +141,23 @@ export const startCallbackServer = async (port = 3000, timeoutMs = 300_000, opti
                 return;
             }
             if (code) {
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                res.end(renderCallbackPage(true));
+                response.writeHead(200, { 'Content-Type': 'text/html' });
+                response.end(renderCallbackPage(true));
                 settle({ code, state });
                 return;
             }
             if (error) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(renderCallbackPage(false, errorDescription ?? error));
+                response.writeHead(400, { 'Content-Type': 'text/html' });
+                response.end(renderCallbackPage(false, errorDescription ?? error));
                 settle({ error, errorDescription });
                 return;
             }
-            res.writeHead(400);
-            res.end('Missing authorization code');
+            response.writeHead(400);
+            response.end('Missing authorization code');
         });
-        server.on('error', (err) => {
+        server.on('error', (serverError) => {
             clearTimeout(timer);
-            reject(err);
+            onServerError(serverError);
         });
         server.listen(port, () => {
             timer = setTimeout(() => settle({
@@ -166,7 +166,7 @@ export const startCallbackServer = async (port = 3000, timeoutMs = 300_000, opti
             }), timeoutMs);
             // Don't let the timeout alone keep the process alive; the listening server does.
             timer.unref();
-            resolve({ server, codePromise });
+            onServerReady({ server, codePromise });
         });
     });
 };
@@ -205,16 +205,16 @@ export const interactiveOAuthFlow = async (config, scopes) => {
     writeCliLine(chalk.gray('Waiting for authorization...'));
     writeCliLine(chalk.gray('(This window will update automatically after you authorize)\n'));
     // Wait for callback
-    const result = await codePromise;
+    const callback = await codePromise;
     // Close server
     server.close();
-    if (result.error) {
-        writeCliLine(chalk.red(`\n✗ Authorization failed: ${result.errorDescription || result.error}\n`));
+    if (callback.error) {
+        writeCliLine(chalk.red(`\n✗ Authorization failed: ${callback.errorDescription || callback.error}\n`));
         return null;
     }
-    if (result.code) {
+    if (callback.code) {
         writeCliLine(chalk.green('\n✓ Authorization successful!\n'));
-        return result.code;
+        return callback.code;
     }
     writeCliLine(chalk.yellow('\n⚠️  No authorization code received.\n'));
     return null;

package/build/auth/oauthMetadata.js

@@ -18,7 +18,7 @@ export const createMetadataRouter = (config) => {
     const router = createRouter();
     // RFC 9728: Protected Resource Metadata endpoint
     // Path: /.well-known/oauth-protected-resource
-    router.get('/.well-known/oauth-protected-resource', (_req, res) => {
+    router.get('/.well-known/oauth-protected-resource', (_request, response) => {
         const authServers = typeof config.authServerMetadata === 'string'
             ? [config.authServerMetadata]
             : [config.authServerMetadata.issuer];
@@ -30,10 +30,10 @@ export const createMetadataRouter = (config) => {
         if (config.resourceDocumentation) {
             metadata.resource_documentation = config.resourceDocumentation;
         }
-        res.json(metadata);
+        response.json(metadata);
     });
     // Optional: Server info endpoint for debugging
-    router.get('/.well-known/mcp-server-info', (_req, res) => {
+    router.get('/.well-known/mcp-server-info', (_request, response) => {
         const serverInfo = {
             name: config.resourceName || 'MCP Resource Server',
             version: '1.0.0',
@@ -53,7 +53,7 @@ export const createMetadataRouter = (config) => {
                 note: 'MCP OAuth scopes (scopes_supported) are separate from eBay API OAuth scopes (ebay.scopes)',
             };
         }
-        res.json(serverInfo);
+        response.json(serverInfo);
     });
     return router;
 };