@jackwener/opencli 1.5.8 → 1.5.9

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[];
+};

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',
+            }];
+    },
+});