@jackwener/opencli 1.5.7 → 1.5.9

package/dist/clis/amazon/shared.js

@@ -0,0 +1,255 @@
+import { ArgumentError, CommandExecutionError } from '../../errors.js';
+export const SITE = 'amazon';
+export const DOMAIN = 'amazon.com';
+export const HOME_URL = 'https://www.amazon.com/';
+export const BESTSELLERS_URL = 'https://www.amazon.com/Best-Sellers/zgbs';
+export const SEARCH_URL_PREFIX = 'https://www.amazon.com/s?k=';
+export const PRODUCT_URL_PREFIX = 'https://www.amazon.com/dp/';
+export const DISCUSSION_URL_PREFIX = 'https://www.amazon.com/product-reviews/';
+export const STRATEGY = 'cookie';
+export const PRIMARY_PRICE_SELECTORS = [
+    '#corePrice_feature_div .a-offscreen',
+    '#corePriceDisplay_desktop_feature_div .a-offscreen',
+    '#corePrice_desktop .a-offscreen',
+    '#apex_desktop .a-offscreen',
+    '#newAccordionRow_0 .a-offscreen',
+    '#price_inside_buybox',
+    '#priceblock_ourprice',
+    '#priceblock_dealprice',
+    '#tp_price_block_total_price_ww',
+];
+const ROBOT_TEXT_PATTERNS = [
+    'Sorry, we just need to make sure you\'re not a robot',
+    'Enter the characters you see below',
+    'Type the characters you see in this image',
+    'To discuss automated access to Amazon data please contact',
+];
+export function cleanText(value) {
+    return typeof value === 'string'
+        ? value.replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim()
+        : '';
+}
+export function cleanMultilineText(value) {
+    return typeof value === 'string'
+        ? value
+            .replace(/\u00a0/g, ' ')
+            .split('\n')
+            .map((line) => line.replace(/\s+/g, ' ').trim())
+            .filter(Boolean)
+            .join('\n')
+        : '';
+}
+export function uniqueNonEmpty(values) {
+    return [...new Set(values.map((value) => cleanText(value)).filter(Boolean))];
+}
+export function buildProvenance(sourceUrl) {
+    return {
+        source_url: sourceUrl,
+        fetched_at: new Date().toISOString(),
+        strategy: STRATEGY,
+    };
+}
+export function buildSearchUrl(query) {
+    const normalized = cleanText(query);
+    if (!normalized) {
+        throw new ArgumentError('amazon search query cannot be empty');
+    }
+    return `${SEARCH_URL_PREFIX}${encodeURIComponent(normalized)}`;
+}
+export function extractAsin(input) {
+    const normalized = cleanText(input);
+    if (!normalized)
+        return null;
+    if (/^[A-Z0-9]{10}$/i.test(normalized)) {
+        return normalized.toUpperCase();
+    }
+    const match = normalized.match(/\/(?:dp|gp\/product|product-reviews)\/([A-Z0-9]{10})/i);
+    return match ? match[1].toUpperCase() : null;
+}
+export function buildProductUrl(input) {
+    const asin = extractAsin(input);
+    if (!asin) {
+        throw new ArgumentError('amazon product expects an ASIN or product URL', 'Example: opencli amazon product B0FJS72893');
+    }
+    return `${PRODUCT_URL_PREFIX}${asin}`;
+}
+export function buildDiscussionUrl(input) {
+    const asin = extractAsin(input);
+    if (!asin) {
+        throw new ArgumentError('amazon discussion expects an ASIN or product URL', 'Example: opencli amazon discussion B0FJS72893');
+    }
+    return `${DISCUSSION_URL_PREFIX}${asin}`;
+}
+export function resolveBestsellersUrl(input) {
+    const normalized = cleanText(input);
+    if (!normalized)
+        return BESTSELLERS_URL;
+    if (normalized === 'root')
+        return BESTSELLERS_URL;
+    if (normalized.startsWith('/')) {
+        return new URL(normalized, HOME_URL).toString();
+    }
+    if (/^https?:\/\//i.test(normalized)) {
+        return canonicalizeAmazonUrl(normalized);
+    }
+    if (normalized.includes('/zgbs/')) {
+        return canonicalizeAmazonUrl(`https://${normalized.replace(/^\/+/, '')}`);
+    }
+    throw new ArgumentError('amazon bestsellers expects a best sellers URL or /zgbs path', 'Example: opencli amazon bestsellers https://www.amazon.com/Best-Sellers/zgbs');
+}
+export function canonicalizeAmazonUrl(input) {
+    try {
+        const url = new URL(input);
+        if (!url.hostname.endsWith(DOMAIN)) {
+            throw new Error('not-amazon');
+        }
+        return url.toString();
+    }
+    catch {
+        throw new ArgumentError('Invalid Amazon URL');
+    }
+}
+export function toAbsoluteAmazonUrl(value) {
+    const normalized = cleanText(value);
+    if (!normalized)
+        return null;
+    try {
+        return new URL(normalized, HOME_URL).toString();
+    }
+    catch {
+        return null;
+    }
+}
+export function normalizeProductUrl(value) {
+    const normalized = cleanText(value);
+    const asin = extractAsin(normalized);
+    if (asin)
+        return buildProductUrl(asin);
+    return toAbsoluteAmazonUrl(normalized);
+}
+export function parsePriceText(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/([$€£])\s*(\d+(?:,\d{3})*(?:\.\d+)?)/);
+    if (!match) {
+        return {
+            price_text: normalized || null,
+            price_value: null,
+            currency: null,
+        };
+    }
+    const currencyMap = {
+        '$': 'USD',
+        '€': 'EUR',
+        '£': 'GBP',
+    };
+    return {
+        price_text: `${match[1]}${match[2]}`,
+        price_value: Number.parseFloat(match[2].replace(/,/g, '')),
+        currency: currencyMap[match[1]] ?? null,
+    };
+}
+export function parseRatingValue(text) {
+    const normalized = cleanText(text);
+    const match = normalized.match(/(\d+(?:\.\d+)?)\s*out of 5/i);
+    return match ? Number.parseFloat(match[1]) : null;
+}
+export function parseReviewCount(text) {
+    const normalized = cleanText(text);
+    const compactMatch = normalized.match(/(\d+(?:\.\d+)?)\s*([kKmM])/);
+    if (compactMatch) {
+        const value = Number.parseFloat(compactMatch[1]);
+        const multiplier = /m/i.test(compactMatch[2]) ? 1_000_000 : 1_000;
+        return Number.isFinite(value) ? Math.round(value * multiplier) : null;
+    }
+    const match = normalized.match(/([\d,]+)/);
+    return match ? Number.parseInt(match[1].replace(/,/g, ''), 10) : null;
+}
+export function extractReviewCountFromCardText(text) {
+    const normalized = cleanMultilineText(text);
+    const match = normalized.match(/out of 5 stars(?:, rating details)?\s*([\d,]+)/i);
+    if (match)
+        return match[1];
+    const numericLine = normalized
+        .split('\n')
+        .map((line) => cleanText(line))
+        .find((line) => /^[\d,]+$/.test(line));
+    return numericLine ?? null;
+}
+export function isAmazonEntity(text) {
+    const normalized = cleanText(text).toLowerCase();
+    return normalized.includes('amazon');
+}
+export function firstMeaningfulLine(text) {
+    return cleanMultilineText(text)
+        .split('\n')
+        .map((line) => cleanText(line))
+        .find(Boolean)
+        ?? '';
+}
+export function trimRatingPrefix(text) {
+    const normalized = cleanText(text);
+    if (!normalized)
+        return null;
+    return normalized.replace(/^\d+(?:\.\d+)?\s*out of 5 stars\s*/i, '').trim() || normalized;
+}
+export function isRobotState(state) {
+    const title = cleanText(state.title);
+    const bodyText = cleanMultilineText(state.body_text);
+    return ROBOT_TEXT_PATTERNS.some((pattern) => title.includes(pattern) || bodyText.includes(pattern));
+}
+export function buildChallengeHint(action) {
+    return [
+        `Open a clean Amazon ${action} page in the shared Chrome profile and clear any robot check first.`,
+        'If you are using CDP, set OPENCLI_CDP_TARGET=amazon.com and avoid parallel Amazon commands against the same browser target.',
+    ].join(' ');
+}
+export async function readPageState(page) {
+    const result = await page.evaluate(`
+    (() => ({
+      href: window.location.href,
+      title: document.title || '',
+      body_text: document.body ? document.body.innerText || '' : '',
+    }))()
+  `);
+    return {
+        href: cleanText(result.href),
+        title: cleanText(result.title),
+        body_text: cleanMultilineText(result.body_text),
+    };
+}
+export async function gotoAndReadState(page, url, settleMs = 2500, action = 'page') {
+    try {
+        await page.goto(url, { settleMs });
+        await page.wait(1.5);
+        return await readPageState(page);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes('Inspected target navigated or closed')
+            || message.includes('Cannot find context with specified id')
+            || message.includes('Target closed')) {
+            throw new CommandExecutionError(`amazon ${action} navigation lost the current browser target`, `${buildChallengeHint(action)} If CDP is attached to a stale tab, open a fresh Amazon tab and retry.`);
+        }
+        throw error;
+    }
+}
+export function assertUsableState(state, action) {
+    if (!isRobotState(state))
+        return;
+    throw new CommandExecutionError(`amazon ${action} hit a robot check`, buildChallengeHint(action));
+}
+export const __test__ = {
+    buildSearchUrl,
+    extractAsin,
+    buildProductUrl,
+    buildDiscussionUrl,
+    resolveBestsellersUrl,
+    parsePriceText,
+    parseRatingValue,
+    parseReviewCount,
+    extractReviewCountFromCardText,
+    isAmazonEntity,
+    trimRatingPrefix,
+    isRobotState,
+    PRIMARY_PRICE_SELECTORS,
+};

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

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

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

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './shared.js';
+describe('amazon shared helpers', () => {
+    it('builds canonical product and discussion URLs from ASINs and product URLs', () => {
+        expect(__test__.buildProductUrl('B0FJS72893')).toBe('https://www.amazon.com/dp/B0FJS72893');
+        expect(__test__.buildProductUrl('https://www.amazon.com/dp/B0FJS72893/ref=something')).toBe('https://www.amazon.com/dp/B0FJS72893');
+        expect(__test__.buildDiscussionUrl('https://www.amazon.com/dp/B0FJS72893')).toBe('https://www.amazon.com/product-reviews/B0FJS72893');
+    });
+    it('parses price, rating, and review-count text', () => {
+        expect(__test__.parsePriceText('1 offer from $34.11')).toEqual({
+            price_text: '$34.11',
+            price_value: 34.11,
+            currency: 'USD',
+        });
+        expect(__test__.parseRatingValue('3.9 out of 5 stars, rating details')).toBe(3.9);
+        expect(__test__.parseReviewCount('27 global ratings')).toBe(27);
+        expect(__test__.parseReviewCount('(2.9K)')).toBe(2900);
+        expect(__test__.parseReviewCount('1.2M global ratings')).toBe(1200000);
+        expect(__test__.extractReviewCountFromCardText('Desk Shelf\n4.3 out of 5 stars\n435\n$25.92')).toBe('435');
+    });
+    it('recognizes robot checks and Amazon-owned merchants', () => {
+        expect(__test__.isAmazonEntity('Ships from Amazon')).toBe(true);
+        expect(__test__.trimRatingPrefix('5.0 out of 5 stars Great value and quality')).toBe('Great value and quality');
+        expect(__test__.isRobotState({
+            title: 'Robot Check',
+            body_text: 'Sorry, we just need to make sure you\'re not a robot',
+        })).toBe(true);
+    });
+    it('requires a real best-sellers URL or path', () => {
+        expect(__test__.resolveBestsellersUrl('/Best-Sellers/zgbs')).toBe('https://www.amazon.com/Best-Sellers/zgbs');
+        expect(() => __test__.resolveBestsellersUrl('desk shelf organizer')).toThrow('amazon bestsellers expects a best sellers URL or /zgbs path');
+    });
+});

package/dist/clis/gemini/ask.d.ts

@@ -0,0 +1 @@
+export declare const askCommand: import("../../registry.js").CliCommand;

package/dist/clis/gemini/ask.js

@@ -0,0 +1,40 @@
+import { cli, Strategy } from '../../registry.js';
+import { GEMINI_DOMAIN, getGeminiTranscriptLines, sendGeminiMessage, startNewGeminiChat, waitForGeminiResponse } from './utils.js';
+function normalizeBooleanFlag(value) {
+    if (typeof value === 'boolean')
+        return value;
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+const NO_RESPONSE_PREFIX = '[NO RESPONSE]';
+export const askCommand = cli({
+    site: 'gemini',
+    name: 'ask',
+    description: 'Send a prompt to Gemini and return only the assistant response',
+    domain: GEMINI_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    defaultFormat: 'plain',
+    timeoutSeconds: 180,
+    args: [
+        { name: 'prompt', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', required: false, help: 'Max seconds to wait (default: 60)', default: '60' },
+        { name: 'new', required: false, help: 'Start a new chat first (true/false, default: false)', default: 'false' },
+    ],
+    columns: ['response'],
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const timeout = parseInt(kwargs.timeout, 10) || 60;
+        const startFresh = normalizeBooleanFlag(kwargs.new);
+        if (startFresh)
+            await startNewGeminiChat(page);
+        const beforeLines = await getGeminiTranscriptLines(page);
+        await sendGeminiMessage(page, prompt);
+        const response = await waitForGeminiResponse(page, beforeLines, prompt, timeout);
+        if (!response) {
+            return [{ response: `💬 ${NO_RESPONSE_PREFIX} No Gemini response within ${timeout}s.` }];
+        }
+        return [{ response: `💬 ${response}` }];
+    },
+});

package/dist/clis/gemini/image.d.ts

@@ -0,0 +1 @@
+export declare const imageCommand: import("../../registry.js").CliCommand;

package/dist/clis/gemini/image.js

@@ -0,0 +1,105 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { saveBase64ToFile } from '../../utils.js';
+import { GEMINI_DOMAIN, exportGeminiImages, getGeminiVisibleImageUrls, sendGeminiMessage, startNewGeminiChat, waitForGeminiImages } from './utils.js';
+function extFromMime(mime) {
+    if (mime.includes('png'))
+        return '.png';
+    if (mime.includes('webp'))
+        return '.webp';
+    if (mime.includes('gif'))
+        return '.gif';
+    return '.jpg';
+}
+function normalizeBooleanFlag(value) {
+    if (typeof value === 'boolean')
+        return value;
+    const normalized = String(value ?? '').trim().toLowerCase();
+    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+function displayPath(filePath) {
+    const home = os.homedir();
+    return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
+}
+function buildImagePrompt(prompt, options) {
+    const extras = [];
+    if (options.ratio)
+        extras.push(`aspect ratio ${options.ratio}`);
+    if (options.style)
+        extras.push(`style ${options.style}`);
+    if (extras.length === 0)
+        return prompt;
+    return `${prompt}
+
+Image requirements: ${extras.join(', ')}.`;
+}
+function normalizeRatio(value) {
+    const normalized = value.trim();
+    const allowed = new Set(['1:1', '16:9', '9:16', '4:3', '3:4', '3:2', '2:3']);
+    return allowed.has(normalized) ? normalized : '1:1';
+}
+async function currentGeminiLink(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    return typeof url === 'string' && url ? url : 'https://gemini.google.com/app';
+}
+export const imageCommand = cli({
+    site: 'gemini',
+    name: 'image',
+    description: 'Generate images with Gemini web and save them locally',
+    domain: GEMINI_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    defaultFormat: 'plain',
+    timeoutSeconds: 240,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to Gemini' },
+        { name: 'rt', default: '1:1', help: 'Ratio shorthand for aspect ratio (1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3)' },
+        { name: 'st', default: '', help: 'Style shorthand, e.g. anime, icon, watercolor' },
+        { name: 'op', default: path.join(os.homedir(), 'tmp', 'gemini-images'), help: 'Output directory shorthand' },
+        { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show Gemini page link' },
+    ],
+    columns: ['status', 'file', 'link'],
+    func: async (page, kwargs) => {
+        const prompt = kwargs.prompt;
+        const ratio = normalizeRatio(String(kwargs.rt ?? '1:1'));
+        const style = String(kwargs.st ?? '').trim();
+        const outputDir = kwargs.op || path.join(os.homedir(), 'tmp', 'gemini-images');
+        const timeout = 120;
+        const startFresh = true;
+        const skipDownloadRaw = kwargs.sd;
+        const skipDownload = skipDownloadRaw === '' || skipDownloadRaw === true || normalizeBooleanFlag(skipDownloadRaw);
+        const effectivePrompt = buildImagePrompt(prompt, {
+            ratio,
+            style: style || undefined,
+        });
+        if (startFresh)
+            await startNewGeminiChat(page);
+        const beforeUrls = await getGeminiVisibleImageUrls(page);
+        await sendGeminiMessage(page, effectivePrompt);
+        const urls = await waitForGeminiImages(page, beforeUrls, timeout);
+        const link = await currentGeminiLink(page);
+        if (!urls.length) {
+            return [{ status: '⚠️ no-images', file: '📁 -', link: `🔗 ${link}` }];
+        }
+        if (skipDownload) {
+            return [{ status: '🎨 generated', file: '📁 -', link: `🔗 ${link}` }];
+        }
+        const assets = await exportGeminiImages(page, urls);
+        if (!assets.length) {
+            return [{ status: '⚠️ export-failed', file: '📁 -', link: `🔗 ${link}` }];
+        }
+        const stamp = Date.now();
+        const results = [];
+        for (let index = 0; index < assets.length; index += 1) {
+            const asset = assets[index];
+            const base64 = asset.dataUrl.replace(/^data:[^;]+;base64,/, '');
+            const suffix = assets.length > 1 ? `_${index + 1}` : '';
+            const filePath = path.join(outputDir, `gemini_${stamp}${suffix}${extFromMime(asset.mimeType)}`);
+            await saveBase64ToFile(base64, filePath);
+            results.push({ status: '✅ saved', file: `📁 ${displayPath(filePath)}`, link: `🔗 ${link}` });
+        }
+        return results;
+    },
+});

package/dist/clis/gemini/new.d.ts

@@ -0,0 +1 @@
+export declare const newCommand: import("../../registry.js").CliCommand;

package/dist/clis/gemini/new.js

@@ -0,0 +1,20 @@
+import { cli, Strategy } from '../../registry.js';
+import { GEMINI_DOMAIN, startNewGeminiChat } from './utils.js';
+export const newCommand = cli({
+    site: 'gemini',
+    name: 'new',
+    description: 'Start a new conversation in Gemini web chat',
+    domain: GEMINI_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Action'],
+    func: async (page) => {
+        const action = await startNewGeminiChat(page);
+        return [{
+                Status: 'Success',
+                Action: action === 'navigate' ? 'Reloaded /app as fallback' : 'Clicked New chat',
+            }];
+    },
+});

package/dist/clis/gemini/utils.d.ts

@@ -0,0 +1,34 @@
+import type { IPage } from '../../types.js';
+export declare const GEMINI_DOMAIN = "gemini.google.com";
+export declare const GEMINI_APP_URL = "https://gemini.google.com/app";
+export interface GeminiPageState {
+    url: string;
+    title: string;
+    isSignedIn: boolean | null;
+    composerLabel: string;
+    canSend: boolean;
+}
+export interface GeminiTurn {
+    Role: 'User' | 'Assistant' | 'System';
+    Text: string;
+}
+export declare function sanitizeGeminiResponseText(value: string, promptText: string): string;
+export declare function collectGeminiTranscriptAdditions(beforeLines: string[], currentLines: string[], promptText: string): string;
+export declare function isOnGemini(page: IPage): Promise<boolean>;
+export declare function ensureGeminiPage(page: IPage): Promise<void>;
+export declare function getGeminiPageState(page: IPage): Promise<GeminiPageState>;
+export declare function startNewGeminiChat(page: IPage): Promise<'clicked' | 'navigate'>;
+export declare function getGeminiVisibleTurns(page: IPage): Promise<GeminiTurn[]>;
+export declare function getGeminiTranscriptLines(page: IPage): Promise<string[]>;
+export declare function sendGeminiMessage(page: IPage, text: string): Promise<'button' | 'enter'>;
+export declare function getGeminiVisibleImageUrls(page: IPage): Promise<string[]>;
+export declare function waitForGeminiImages(page: IPage, beforeUrls: string[], timeoutSeconds: number): Promise<string[]>;
+export interface GeminiImageAsset {
+    url: string;
+    dataUrl: string;
+    mimeType: string;
+    width: number;
+    height: number;
+}
+export declare function exportGeminiImages(page: IPage, urls: string[]): Promise<GeminiImageAsset[]>;
+export declare function waitForGeminiResponse(page: IPage, beforeLines: string[], promptText: string, timeoutSeconds: number): Promise<string>;