@jackwener/opencli 1.5.7 → 1.5.9

package/dist/clis/amazon/offer.js

@@ -0,0 +1,140 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { buildProductUrl, buildProvenance, cleanText, extractAsin, isAmazonEntity, normalizeProductUrl, PRIMARY_PRICE_SELECTORS, parsePriceText, assertUsableState, gotoAndReadState, } from './shared.js';
+const OFFER_FACT_SELECTOR = [
+    '#sellerProfileTriggerId',
+    '#shipsFromSoldByInsideBuyBox_feature_div',
+    '#fulfillerInfoFeature_feature_div',
+    '#merchantInfoFeature_feature_div',
+    '#tabular-buybox-container',
+    '#merchant-info',
+].join(', ');
+function collapseAdjacentWords(text) {
+    const parts = cleanText(text).split(' ').filter(Boolean);
+    const deduped = [];
+    for (const part of parts) {
+        if (deduped[deduped.length - 1] === part)
+            continue;
+        deduped.push(part);
+    }
+    return deduped.join(' ');
+}
+function extractShipsFrom(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/Ships from\s+(.+?)(?=Sold by|and Fulfilled by|$)/i);
+    return match ? collapseAdjacentWords(match[1].replace(/Ships from/ig, '')) : null;
+}
+function extractSoldBy(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/Sold by\s+(.+?)(?=and Fulfilled by|Ships from|$)/i);
+    return match ? collapseAdjacentWords(match[1]) : null;
+}
+function isDeliveryLocationBlocked(text) {
+    const normalized = cleanText(text).toLowerCase();
+    return normalized.includes('cannot be shipped to your selected delivery location')
+        || normalized.includes('similar items shipping to')
+        || normalized.includes('deliver to hong kong');
+}
+function normalizeOfferPayload(payload) {
+    const asin = extractAsin(payload.href ?? '') ?? null;
+    const sourceUrl = cleanText(payload.href) || buildProductUrl(payload.href ?? '');
+    const price = parsePriceText(payload.price_text);
+    const merchantInfo = cleanText(payload.merchant_info) || null;
+    const soldBy = cleanText(payload.sold_by)
+        || extractSoldBy(payload.ships_from_text ?? '')
+        || extractSoldBy(merchantInfo ?? '')
+        || null;
+    const shipsFrom = extractShipsFrom(payload.ships_from_text ?? '')
+        || extractShipsFrom(merchantInfo ?? '')
+        || cleanText(payload.ships_from_text)
+        || null;
+    const provenance = buildProvenance(sourceUrl);
+    return {
+        asin,
+        product_url: normalizeProductUrl(payload.href),
+        ...provenance,
+        price_text: price.price_text,
+        price_value: price.price_value,
+        currency: price.currency,
+        merchant_info_text: merchantInfo,
+        sold_by: soldBy,
+        ships_from: shipsFrom,
+        offer_listing_url: cleanText(payload.offer_link) || null,
+        review_url: cleanText(payload.review_url) || null,
+        qa_url: cleanText(payload.qa_url) || null,
+        is_amazon_sold: isAmazonEntity(soldBy),
+        is_amazon_fulfilled: isAmazonEntity(shipsFrom) || /fulfilled by amazon/i.test(merchantInfo ?? ''),
+    };
+}
+async function readOfferPayload(page, input) {
+    const url = buildProductUrl(input);
+    const state = await gotoAndReadState(page, url, 2500, 'offer');
+    assertUsableState(state, 'offer');
+    // Reconnecting to an existing Amazon target can surface the product page
+    // before the buy-box / merchant blocks are reattached to the DOM.
+    await page.wait({ selector: OFFER_FACT_SELECTOR, timeout: 6 }).catch(() => { });
+    return await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      title: document.title || '',
+      price_text: (() => {
+        const selectors = ${JSON.stringify(PRIMARY_PRICE_SELECTORS)};
+        for (const selector of selectors) {
+          const text = document.querySelector(selector)?.textContent || '';
+          if (text.trim()) return text;
+        }
+        return '';
+      })(),
+      merchant_info: document.querySelector('#merchant-info')?.textContent || '',
+      sold_by: document.querySelector('#sellerProfileTriggerId')?.textContent || '',
+      ships_from_text:
+        document.querySelector('#shipsFromSoldByInsideBuyBox_feature_div')?.textContent
+        || document.querySelector('#fulfillerInfoFeature_feature_div')?.textContent
+        || document.querySelector('#merchantInfoFeature_feature_div')?.textContent
+        || document.querySelector('#tabular-buybox-container')?.textContent
+        || '',
+      offer_link: document.querySelector('a[href*="/gp/offer-listing/"]')?.href || '',
+      review_url: document.querySelector('a[href*="#customerReviews"]')?.href || '',
+      qa_url: document.querySelector('a[href*="ask/questions"]')?.href || '',
+      buybox_text:
+        document.querySelector('#desktop_qualifiedBuyBox')?.textContent
+        || document.querySelector('#buybox')?.textContent
+        || '',
+    }))()
+  `);
+}
+cli({
+    site: 'amazon',
+    name: 'offer',
+    description: 'Amazon seller, buy box, and fulfillment facts from the product page',
+    domain: 'amazon.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'input',
+            required: true,
+            positional: true,
+            help: 'ASIN or product URL, for example B0FJS72893',
+        },
+    ],
+    columns: ['asin', 'price_text', 'sold_by', 'ships_from', 'is_amazon_sold', 'is_amazon_fulfilled'],
+    func: async (page, kwargs) => {
+        const input = String(kwargs.input ?? '');
+        const payload = await readOfferPayload(page, input);
+        const normalized = normalizeOfferPayload(payload);
+        if (!normalized.sold_by && !normalized.ships_from && !normalized.merchant_info_text) {
+            if (isDeliveryLocationBlocked(payload.buybox_text)) {
+                throw new CommandExecutionError('amazon offer buy box is blocked by the current delivery location', 'The shared Chrome profile is not set to the target US delivery address. Switch Amazon delivery location to the requested US destination, reopen the product page, and retry.');
+            }
+            throw new CommandExecutionError('amazon offer surface did not expose seller or fulfillment facts', 'The product page may have changed. Open the product page in Chrome, make sure the buy box is visible, and retry.');
+        }
+        return [normalized];
+    },
+});
+export const __test__ = {
+    extractShipsFrom,
+    extractSoldBy,
+    isDeliveryLocationBlocked,
+    normalizeOfferPayload,
+};

package/dist/clis/amazon/offer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/amazon/offer.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './offer.js';
+describe('amazon offer normalization', () => {
+    it('extracts sold-by and fulfillment facts from product offer text', () => {
+        const result = __test__.normalizeOfferPayload({
+            href: 'https://www.amazon.com/dp/B0FJS72893',
+            price_text: '$15.99',
+            merchant_info: '',
+            sold_by: 'KUATUDIRECT',
+            ships_from_text: 'Ships from Amazon',
+            offer_link: null,
+            review_url: 'https://www.amazon.com/dp/B0FJS72893#customerReviews',
+            qa_url: null,
+        });
+        expect(result.asin).toBe('B0FJS72893');
+        expect(result.sold_by).toBe('KUATUDIRECT');
+        expect(result.ships_from).toBe('Amazon');
+        expect(result.is_amazon_sold).toBe(false);
+        expect(result.is_amazon_fulfilled).toBe(true);
+    });
+    it('parses merchant info fallback text', () => {
+        expect(__test__.extractSoldBy('Sold by Example Seller and Fulfilled by Amazon.')).toBe('Example Seller');
+        expect(__test__.extractShipsFrom('Ships from Amazon')).toBe('Amazon');
+    });
+    it('detects delivery-location blocking in the buy box text', () => {
+        expect(__test__.isDeliveryLocationBlocked('This item cannot be shipped to your selected delivery location. Similar items shipping to Hong Kong')).toBe(true);
+        expect(__test__.isDeliveryLocationBlocked('Ships from Amazon')).toBe(false);
+    });
+});

package/dist/clis/amazon/product.d.ts

@@ -0,0 +1,18 @@
+interface ProductPayload {
+    href?: string;
+    title?: string;
+    product_title?: string | null;
+    byline?: string | null;
+    price_text?: string | null;
+    rating_text?: string | null;
+    review_count_text?: string | null;
+    review_url?: string | null;
+    qa_url?: string | null;
+    bullets?: string[];
+    breadcrumbs?: string[];
+}
+declare function normalizeProductPayload(payload: ProductPayload): Record<string, unknown>;
+export declare const __test__: {
+    normalizeProductPayload: typeof normalizeProductPayload;
+};
+export {};

package/dist/clis/amazon/product.js

@@ -0,0 +1,92 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { buildProductUrl, buildProvenance, cleanText, extractAsin, PRIMARY_PRICE_SELECTORS, parsePriceText, parseRatingValue, parseReviewCount, normalizeProductUrl, uniqueNonEmpty, assertUsableState, gotoAndReadState, } from './shared.js';
+const PRODUCT_TITLE_SELECTOR = '#productTitle, #title span, [data-feature-name="title"] h1 span';
+const BYLINE_SELECTOR = '#bylineInfo, [data-feature-name="bylineInfo"] #bylineInfo';
+function normalizeProductPayload(payload) {
+    const sourceUrl = cleanText(payload.href) || buildProductUrl(cleanText(payload.product_title) || cleanText(payload.href));
+    const asin = extractAsin(payload.href ?? '') ?? null;
+    const price = parsePriceText(payload.price_text);
+    const ratingText = cleanText(payload.rating_text) || null;
+    const reviewCountText = cleanText(payload.review_count_text) || null;
+    const provenance = buildProvenance(sourceUrl);
+    return {
+        asin,
+        title: cleanText(payload.product_title) || cleanText(payload.title) || null,
+        product_url: normalizeProductUrl(payload.href),
+        ...provenance,
+        brand_text: cleanText(payload.byline) || null,
+        price_text: price.price_text,
+        price_value: price.price_value,
+        currency: price.currency,
+        rating_text: ratingText,
+        rating_value: parseRatingValue(ratingText),
+        review_count_text: reviewCountText,
+        review_count: parseReviewCount(reviewCountText),
+        review_url: cleanText(payload.review_url) || null,
+        qa_url: cleanText(payload.qa_url) || null,
+        breadcrumbs: uniqueNonEmpty(payload.breadcrumbs ?? []),
+        bullet_points: uniqueNonEmpty(payload.bullets ?? []),
+    };
+}
+async function readProductPayload(page, input) {
+    const url = buildProductUrl(input);
+    const state = await gotoAndReadState(page, url, 2500, 'product');
+    assertUsableState(state, 'product');
+    // Amazon can report a "stable" DOM before the product title block hydrates,
+    // especially when reconnecting to an existing shared CDP target.
+    await page.wait({ selector: PRODUCT_TITLE_SELECTOR, timeout: 6 }).catch(() => { });
+    return await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      title: document.title || '',
+      product_title: document.querySelector(${JSON.stringify(PRODUCT_TITLE_SELECTOR)})?.textContent || '',
+      byline: document.querySelector(${JSON.stringify(BYLINE_SELECTOR)})?.textContent || '',
+      price_text: (() => {
+        const selectors = ${JSON.stringify(PRIMARY_PRICE_SELECTORS)};
+        for (const selector of selectors) {
+          const text = document.querySelector(selector)?.textContent || '';
+          if (text.trim()) return text;
+        }
+        return '';
+      })(),
+      rating_text:
+        document.querySelector('#acrPopover')?.getAttribute('title')
+        || document.querySelector('#acrPopover')?.textContent
+        || '',
+      review_count_text: document.querySelector('#acrCustomerReviewText')?.textContent || '',
+      review_url: document.querySelector('a[href*="#customerReviews"]')?.href || '',
+      qa_url: document.querySelector('a[href*="ask/questions"]')?.href || '',
+      bullets: Array.from(document.querySelectorAll('#feature-bullets li .a-list-item')).map((node) => node.textContent || ''),
+      breadcrumbs: Array.from(document.querySelectorAll('#wayfinding-breadcrumbs_feature_div a')).map((node) => node.textContent || ''),
+    }))()
+  `);
+}
+cli({
+    site: 'amazon',
+    name: 'product',
+    description: 'Amazon product page facts for candidate validation',
+    domain: 'amazon.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'input',
+            required: true,
+            positional: true,
+            help: 'ASIN or product URL, for example B0FJS72893',
+        },
+    ],
+    columns: ['asin', 'title', 'price_text', 'rating_value', 'review_count'],
+    func: async (page, kwargs) => {
+        const input = String(kwargs.input ?? '');
+        const payload = await readProductPayload(page, input);
+        if (!cleanText(payload.product_title)) {
+            throw new CommandExecutionError('amazon product page did not expose product content', 'The product page may have changed or hit a robot check. Open the product page in Chrome and retry.');
+        }
+        return [normalizeProductPayload(payload)];
+    },
+});
+export const __test__ = {
+    normalizeProductPayload,
+};

package/dist/clis/amazon/product.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/amazon/product.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './product.js';
+describe('amazon product normalization', () => {
+    it('normalizes product facts from the product page', () => {
+        const result = __test__.normalizeProductPayload({
+            href: 'https://www.amazon.com/dp/B0FJS72893',
+            title: 'Amazon.com: KVTUKIAIT Desktop Shelf Organizer',
+            product_title: 'White Desktop Shelf Organizer for Top of Desk',
+            byline: 'Visit the KVTUKIAIT Store',
+            price_text: '$15.99',
+            rating_text: '3.9 out of 5 stars',
+            review_count_text: '27 ratings',
+            review_url: 'https://www.amazon.com/dp/B0FJS72893#customerReviews',
+            qa_url: null,
+            bullets: ['SPACE-SAVING DESK SHELF ORGANIZER', 'SMALL AND STYLISH AESTHETIC DECOR'],
+            breadcrumbs: ['Office Products', 'Desktop & Off-Surface Shelves'],
+        });
+        expect(result.asin).toBe('B0FJS72893');
+        expect(result.price_value).toBe(15.99);
+        expect(result.rating_value).toBe(3.9);
+        expect(result.review_count).toBe(27);
+        expect(result.breadcrumbs).toEqual(['Office Products', 'Desktop & Off-Surface Shelves']);
+    });
+});

package/dist/clis/amazon/search.d.ts

@@ -0,0 +1,18 @@
+interface SearchPayload {
+    href?: string;
+    cards?: Array<{
+        asin?: string;
+        title?: string;
+        href?: string;
+        price_text?: string | null;
+        rating_text?: string | null;
+        review_count_text?: string | null;
+        sponsored?: boolean;
+        badge_texts?: string[];
+    }>;
+}
+declare function normalizeSearchCandidate(candidate: NonNullable<SearchPayload['cards']>[number], rank: number, sourceUrl: string): Record<string, unknown>;
+export declare const __test__: {
+    normalizeSearchCandidate: typeof normalizeSearchCandidate;
+};
+export {};

package/dist/clis/amazon/search.js

@@ -0,0 +1,87 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { buildProvenance, buildSearchUrl, cleanText, extractAsin, normalizeProductUrl, parsePriceText, parseRatingValue, parseReviewCount, assertUsableState, gotoAndReadState, } from './shared.js';
+function normalizeSearchCandidate(candidate, rank, sourceUrl) {
+    const productUrl = normalizeProductUrl(candidate.href);
+    const asin = extractAsin(candidate.asin ?? '') ?? extractAsin(productUrl ?? '') ?? null;
+    const price = parsePriceText(candidate.price_text);
+    const ratingText = cleanText(candidate.rating_text) || null;
+    const reviewCountText = cleanText(candidate.review_count_text) || null;
+    const provenance = buildProvenance(sourceUrl);
+    return {
+        rank,
+        asin,
+        title: cleanText(candidate.title) || null,
+        product_url: productUrl,
+        ...provenance,
+        price_text: price.price_text,
+        price_value: price.price_value,
+        currency: price.currency,
+        rating_text: ratingText,
+        rating_value: parseRatingValue(ratingText),
+        review_count_text: reviewCountText,
+        review_count: parseReviewCount(reviewCountText),
+        is_sponsored: candidate.sponsored === true,
+        badges: (candidate.badge_texts ?? []).map((value) => cleanText(value)).filter(Boolean),
+    };
+}
+async function readSearchPayload(page, query) {
+    const url = buildSearchUrl(query);
+    const state = await gotoAndReadState(page, url, 2500, 'search');
+    assertUsableState(state, 'search');
+    return await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      cards: Array.from(document.querySelectorAll('[data-component-type="s-search-result"]'))
+        .map((card) => ({
+          asin: card.getAttribute('data-asin') || '',
+          title: card.querySelector('h2')?.textContent || '',
+          href: card.querySelector('a.a-link-normal[href*="/dp/"]')?.href || '',
+          price_text: card.querySelector('.a-price .a-offscreen')?.textContent || '',
+          rating_text: card.querySelector('[aria-label*="out of 5 stars"]')?.getAttribute('aria-label') || '',
+          review_count_text: card.querySelector('a[href*="#customerReviews"]')?.textContent || '',
+          sponsored: /sponsored/i.test(card.innerText || ''),
+          badge_texts: Array.from(card.querySelectorAll('.a-badge-text')).map((node) => node.textContent || ''),
+        })),
+    }))()
+  `);
+}
+cli({
+    site: 'amazon',
+    name: 'search',
+    description: 'Amazon search results for product discovery and coarse filtering',
+    domain: 'amazon.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    args: [
+        {
+            name: 'query',
+            required: true,
+            positional: true,
+            help: 'Search query, for example "desk shelf organizer"',
+        },
+        {
+            name: 'limit',
+            type: 'int',
+            default: 20,
+            help: 'Maximum number of results to return (default 20)',
+        },
+    ],
+    columns: ['rank', 'asin', 'title', 'price_text', 'rating_value', 'review_count'],
+    func: async (page, kwargs) => {
+        const query = String(kwargs.query ?? '');
+        const limit = Math.max(1, Number(kwargs.limit) || 20);
+        const payload = await readSearchPayload(page, query);
+        const sourceUrl = cleanText(payload.href) || buildSearchUrl(query);
+        const cards = (payload.cards ?? [])
+            .filter((card) => cleanText(card.asin) && cleanText(card.title))
+            .slice(0, limit);
+        if (cards.length === 0) {
+            throw new CommandExecutionError('amazon search did not expose any product cards', 'The search page may have changed or hit a robot check. Open the same query in Chrome, verify the page is visible, and retry.');
+        }
+        return cards.map((card, index) => normalizeSearchCandidate(card, index + 1, sourceUrl));
+    },
+});
+export const __test__ = {
+    normalizeSearchCandidate,
+};

package/dist/clis/amazon/search.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/amazon/search.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './search.js';
+describe('amazon search normalization', () => {
+    it('normalizes search cards into research-friendly fields', () => {
+        const result = __test__.normalizeSearchCandidate({
+            asin: 'B0FJS72893',
+            title: 'White Desktop Shelf Organizer for Top of Desk',
+            href: 'https://www.amazon.com/KVTUKIAIT-White-Desktop-Shelf-Organizer/dp/B0FJS72893/ref=sr_1_1',
+            price_text: '$15.99',
+            rating_text: '3.9 out of 5 stars, rating details',
+            review_count_text: '(27)',
+            sponsored: false,
+            badge_texts: ['Limited time deal'],
+        }, 1, 'https://www.amazon.com/s?k=desk+shelf+organizer');
+        expect(result.asin).toBe('B0FJS72893');
+        expect(result.product_url).toBe('https://www.amazon.com/dp/B0FJS72893');
+        expect(result.price_value).toBe(15.99);
+        expect(result.rating_value).toBe(3.9);
+        expect(result.review_count).toBe(27);
+        expect(result.badges).toEqual(['Limited time deal']);
+    });
+});

package/dist/clis/amazon/shared.d.ts

@@ -0,0 +1,64 @@
+import type { IPage } from '../../types.js';
+export declare const SITE = "amazon";
+export declare const DOMAIN = "amazon.com";
+export declare const HOME_URL = "https://www.amazon.com/";
+export declare const BESTSELLERS_URL = "https://www.amazon.com/Best-Sellers/zgbs";
+export declare const SEARCH_URL_PREFIX = "https://www.amazon.com/s?k=";
+export declare const PRODUCT_URL_PREFIX = "https://www.amazon.com/dp/";
+export declare const DISCUSSION_URL_PREFIX = "https://www.amazon.com/product-reviews/";
+export declare const STRATEGY = "cookie";
+export declare const PRIMARY_PRICE_SELECTORS: string[];
+export interface ProvenanceFields {
+    source_url: string;
+    fetched_at: string;
+    strategy: string;
+}
+export interface PageState {
+    href: string;
+    title: string;
+    body_text: string;
+}
+export interface PriceValue {
+    price_text: string | null;
+    price_value: number | null;
+    currency: string | null;
+}
+export declare function cleanText(value: unknown): string;
+export declare function cleanMultilineText(value: unknown): string;
+export declare function uniqueNonEmpty(values: Array<string | null | undefined>): string[];
+export declare function buildProvenance(sourceUrl: string): ProvenanceFields;
+export declare function buildSearchUrl(query: string): string;
+export declare function extractAsin(input: string): string | null;
+export declare function buildProductUrl(input: string): string;
+export declare function buildDiscussionUrl(input: string): string;
+export declare function resolveBestsellersUrl(input?: string): string;
+export declare function canonicalizeAmazonUrl(input: string): string;
+export declare function toAbsoluteAmazonUrl(value: string | null | undefined): string | null;
+export declare function normalizeProductUrl(value: string | null | undefined): string | null;
+export declare function parsePriceText(text: string | null | undefined): PriceValue;
+export declare function parseRatingValue(text: string | null | undefined): number | null;
+export declare function parseReviewCount(text: string | null | undefined): number | null;
+export declare function extractReviewCountFromCardText(text: string | null | undefined): string | null;
+export declare function isAmazonEntity(text: string | null | undefined): boolean;
+export declare function firstMeaningfulLine(text: string | null | undefined): string;
+export declare function trimRatingPrefix(text: string | null | undefined): string | null;
+export declare function isRobotState(state: Partial<PageState>): boolean;
+export declare function buildChallengeHint(action: string): string;
+export declare function readPageState(page: IPage): Promise<PageState>;
+export declare function gotoAndReadState(page: IPage, url: string, settleMs?: number, action?: string): Promise<PageState>;
+export declare function assertUsableState(state: PageState, action: string): void;
+export declare const __test__: {
+    buildSearchUrl: typeof buildSearchUrl;
+    extractAsin: typeof extractAsin;
+    buildProductUrl: typeof buildProductUrl;
+    buildDiscussionUrl: typeof buildDiscussionUrl;
+    resolveBestsellersUrl: typeof resolveBestsellersUrl;
+    parsePriceText: typeof parsePriceText;
+    parseRatingValue: typeof parseRatingValue;
+    parseReviewCount: typeof parseReviewCount;
+    extractReviewCountFromCardText: typeof extractReviewCountFromCardText;
+    isAmazonEntity: typeof isAmazonEntity;
+    trimRatingPrefix: typeof trimRatingPrefix;
+    isRobotState: typeof isRobotState;
+    PRIMARY_PRICE_SELECTORS: string[];
+};