@jackwener/opencli 1.7.8 → 1.7.10

package/clis/claude/utils.js

@@ -0,0 +1,440 @@
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+export const CLAUDE_DOMAIN = 'claude.ai';
+export const CLAUDE_URL = 'https://claude.ai/new';
+export const COMPOSER_SELECTOR = '[data-testid="chat-input"]';
+export const MESSAGE_SELECTOR = '.font-claude-response';
+export const MODEL_DROPDOWN_SELECTOR = '[data-testid="model-selector-dropdown"]';
+
+const MODEL_DISPLAY_NAMES = {
+    sonnet: 'Sonnet 4.6',
+    opus: 'Opus 4.7',
+    haiku: 'Haiku 4.5',
+};
+
+export async function isOnClaude(page) {
+    const url = await page.evaluate('window.location.href').catch(() => '');
+    if (typeof url !== 'string' || !url) return false;
+    try {
+        const h = new URL(url).hostname;
+        return h === CLAUDE_DOMAIN || h.endsWith(`.${CLAUDE_DOMAIN}`);
+    } catch {
+        return false;
+    }
+}
+
+export async function ensureOnClaude(page) {
+    if (await isOnClaude(page)) return false;
+    await page.goto(CLAUDE_URL);
+    await page.wait(3);
+    return true;
+}
+
+export async function getPageState(page) {
+    return page.evaluate(`(() => {
+        var composer = document.querySelector('${COMPOSER_SELECTOR}');
+        var userMenu = document.querySelector('[data-testid="user-menu-button"]');
+        return {
+            url: window.location.href,
+            title: document.title,
+            hasComposer: !!composer,
+            isLoggedIn: !!userMenu,
+        };
+    })()`);
+}
+
+export async function ensureClaudeLogin(page, message = 'Claude requires a logged-in browser session.') {
+    const state = await getPageState(page);
+    if (!state.isLoggedIn) {
+        throw new AuthRequiredError(CLAUDE_DOMAIN, message);
+    }
+    return state;
+}
+
+export async function ensureClaudeComposer(page, message = 'Claude composer is not available on the current page.') {
+    const state = await ensureClaudeLogin(page, message);
+    if (!state.hasComposer) {
+        throw new CommandExecutionError(message);
+    }
+    return state;
+}
+
+export function requireNonEmptyPrompt(prompt, commandName) {
+    const text = String(prompt ?? '').trim();
+    if (!text) {
+        throw new ArgumentError(
+            `${commandName} prompt cannot be empty`,
+            `Example: opencli ${commandName} "hello"`,
+        );
+    }
+    return text;
+}
+
+export function requirePositiveInt(value, flagLabel, hint) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new ArgumentError(`${flagLabel} must be a positive integer`, hint);
+    }
+    return value;
+}
+
+export function requireConversationId(value) {
+    const id = String(value ?? '').trim();
+    if (!id) {
+        throw new ArgumentError(
+            'claude detail requires a conversation id',
+            'Example: opencli claude detail 123e4567-e89b-12d3-a456-426614174000',
+        );
+    }
+    return id;
+}
+
+export async function getVisibleMessages(page) {
+    const result = await page.evaluate(`(() => {
+        var nodes = document.querySelectorAll('[data-testid="user-message"], ${MESSAGE_SELECTOR}');
+        var rows = [];
+        Array.from(nodes).forEach(function(el) {
+            var isUser = el.getAttribute('data-testid') === 'user-message';
+            var raw = (el.innerText || '').trim();
+            if (!isUser) {
+                var parts = raw.split(/\\n\\n+/);
+                while (parts.length > 1 && /^(Thought|View)\\b/i.test(parts[0])) parts.shift();
+                raw = parts.join('\\n\\n').trim();
+            }
+            if (raw) rows.push({ role: isUser ? 'user' : 'assistant', text: raw });
+        });
+        return rows;
+    })()`);
+    if (!Array.isArray(result)) return [];
+    return result.map(function(r, i) { return { Index: i, Role: r.role, Text: r.text }; });
+}
+
+export async function getConversationList(page) {
+    if (!(await isOnClaude(page)) || !(await page.evaluate('window.location.href') || '').includes('/recents')) {
+        await page.goto('https://claude.ai/recents');
+        await page.wait(3);
+    }
+    const items = await page.evaluate(`(() => {
+        var links = Array.from(document.querySelectorAll('a[href*="/chat/"]'));
+        return links.map(function(link, i) {
+            var href = link.getAttribute('href') || '';
+            var idMatch = href.match(/\\/chat\\/([a-f0-9-]+)/);
+            return {
+                Index: i + 1,
+                Id: idMatch ? idMatch[1] : href,
+                Title: (link.innerText || '').trim().split('\\n')[0].trim() || '(untitled)',
+                Url: href.startsWith('http') ? href : ('https://claude.ai' + href),
+            };
+        });
+    })()`);
+    return Array.isArray(items) ? items : [];
+}
+
+export async function selectModel(page, modelName) {
+    const display = MODEL_DISPLAY_NAMES[String(modelName).toLowerCase()];
+    if (!display) return { ok: false };
+
+    const opened = await page.evaluate(`(() => {
+        var trigger = document.querySelector('${MODEL_DROPDOWN_SELECTOR}');
+        if (!trigger) return { ok: false };
+        var label = trigger.getAttribute('aria-label') || '';
+        if (label.indexOf(${JSON.stringify(display)}) >= 0) {
+            return { ok: true, toggled: false };
+        }
+        trigger.click();
+        return { ok: true, opened: true };
+    })()`);
+
+    if (!opened?.ok) return opened;
+    if (!opened.opened) return opened;
+
+    await page.wait(0.6);
+
+    return page.evaluate(`(() => {
+        var items = Array.from(document.querySelectorAll('div[role="menuitemradio"]'));
+        var target = items.find(function(el) { return (el.innerText || '').indexOf(${JSON.stringify(display)}) >= 0; });
+        if (!target) return { ok: false };
+        // Free-tier locked options carry an inline "Upgrade" button next to the label.
+        var upgrade = target.querySelector('button');
+        if (upgrade && (upgrade.innerText || '').toLowerCase().indexOf('upgrade') >= 0) {
+            document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+            return { ok: false, upgrade: true };
+        }
+        var alreadySelected = target.getAttribute('aria-checked') === 'true';
+        if (!alreadySelected) target.click();
+        else document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        return { ok: true, toggled: !alreadySelected };
+    })()`);
+}
+
+export async function setAdaptiveThinking(page, enabled) {
+    const opened = await page.evaluate(`(() => {
+        var trigger = document.querySelector('${MODEL_DROPDOWN_SELECTOR}');
+        if (!trigger) return { ok: false };
+        trigger.click();
+        return { ok: true };
+    })()`);
+    if (!opened?.ok) return { ok: false };
+
+    await page.wait(0.6);
+
+    return page.evaluate(`(() => {
+        var items = Array.from(document.querySelectorAll('div[role="menuitem"]'));
+        var target = items.find(function(el) { return (el.innerText || '').indexOf('Adaptive thinking') >= 0; });
+        if (!target) {
+            document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+            return { ok: false };
+        }
+        var isActive = target.getAttribute('aria-checked') === 'true';
+        if (${enabled} !== isActive) target.click();
+        else document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }));
+        return { ok: true, toggled: ${enabled} !== isActive };
+    })()`);
+}
+
+export async function sendMessage(page, prompt) {
+    const promptJson = JSON.stringify(prompt);
+    const composerReady = await page.evaluate(`(() => {
+        var box = document.querySelector('${COMPOSER_SELECTOR}');
+        if (!box) return false;
+        box.focus();
+        // ProseMirror editors hold content in nested <p>; clear via Range/delete
+        // rather than .value or textContent, which the editor won't notice.
+        var sel = window.getSelection();
+        sel.removeAllRanges();
+        var range = document.createRange();
+        range.selectNodeContents(box);
+        sel.addRange(range);
+        document.execCommand('delete', false);
+        return true;
+    })()`);
+    if (!composerReady) return { ok: false, reason: 'composer not found' };
+
+    let typedNatively = false;
+    if (page.nativeType) {
+        try {
+            await page.nativeType(prompt);
+            typedNatively = true;
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (!msg.includes('Unknown action') && !msg.includes('not supported')) throw err;
+        }
+    }
+    if (!typedNatively) {
+        await page.evaluate(`(() => {
+            var box = document.querySelector('${COMPOSER_SELECTOR}');
+            if (!box) return;
+            box.focus();
+            document.execCommand('insertText', false, ${promptJson});
+        })()`);
+    }
+
+    await page.wait(1.2);
+
+    return page.evaluate(`(() => {
+        var ariaCandidates = [
+            'button[aria-label="Send Message"]',
+            'button[aria-label="Send message"]',
+            'button[aria-label="Send"]',
+            'button[aria-label*="Send"]',
+        ];
+        for (var i = 0; i < ariaCandidates.length; i++) {
+            var btn = document.querySelector(ariaCandidates[i]);
+            if (btn && !btn.disabled) { btn.click(); return { ok: true }; }
+        }
+        // Fallback: rightmost enabled button with an svg in the composer container.
+        var box = document.querySelector('${COMPOSER_SELECTOR}');
+        if (box) {
+            var c = box.parentElement;
+            for (var hop = 0; hop < 6 && c; hop++) {
+                var btns = Array.from(c.querySelectorAll('button')).filter(function(b) { return !b.disabled && b.querySelector('svg'); });
+                if (btns.length) { btns[btns.length - 1].click(); return { ok: true, method: 'fallback' }; }
+                c = c.parentElement;
+            }
+        }
+        var box2 = document.querySelector('${COMPOSER_SELECTOR}');
+        if (box2) {
+            box2.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+            return { ok: true, method: 'enter' };
+        }
+        return { ok: false, reason: 'send button not found' };
+    })()`);
+}
+
+export async function getBubbleCount(page) {
+    const count = await page.evaluate(`(() => {
+        return document.querySelectorAll('${MESSAGE_SELECTOR}').length;
+    })()`);
+    return count || 0;
+}
+
+export async function waitForResponse(page, baselineCount, prompt, timeoutMs) {
+    const startTime = Date.now();
+    let lastText = '';
+    let stableCount = 0;
+
+    while (Date.now() - startTime < timeoutMs) {
+        await page.wait(3);
+
+        let result;
+        try {
+            result = await page.evaluate(`(() => {
+                var bubbles = document.querySelectorAll('${MESSAGE_SELECTOR}');
+                // Adaptive thinking renders "Thought process" labels at the top
+                // of the response (often duplicated for the expand/collapse widget).
+                // Strip them so the row value is the actual answer text.
+                var texts = Array.from(bubbles).map(function(b) {
+                    var raw = (b.innerText || '').trim();
+                    // Drop leading paragraphs that are widget labels:
+                    //   "Thought process" / "Thought for Xs" — Adaptive thinking expand widget
+                    //   "View uploaded image" / "View attachment" — file thumbnail label
+                    // These render twice (collapsed + expanded) and are followed by a blank line.
+                    var parts = raw.split(/\\n\\n+/);
+                    while (parts.length > 1 && /^(Thought|View)\\b/i.test(parts[0])) parts.shift();
+                    return parts.join('\\n\\n').trim();
+                }).filter(Boolean);
+                return {
+                    count: texts.length,
+                    last: texts[texts.length - 1] || '',
+                    streaming: !!document.querySelector('[data-is-streaming="true"]'),
+                };
+            })()`);
+        } catch {
+            continue;
+        }
+
+        if (!result) continue;
+
+        const candidate = result.last;
+        if (!candidate || candidate === prompt.trim()) continue;
+        if (result.count <= baselineCount) continue;
+        if (result.streaming) {
+            lastText = candidate;
+            stableCount = 0;
+            continue;
+        }
+
+        if (candidate === lastText) {
+            stableCount++;
+            if (stableCount >= 3) return candidate;
+        } else {
+            stableCount = 0;
+            lastText = candidate;
+        }
+    }
+
+    return lastText || null;
+}
+
+async function waitForFilePreview(page, fileName) {
+    for (let attempt = 0; attempt < 12; attempt++) {
+        await page.wait(1);
+        const ready = await page.evaluate(`(() => {
+            // Claude renders attachments as data-testid="file-thumbnail" cards with
+            // a sibling Remove button. Either signal indicates the file took.
+            if (document.querySelector('[data-testid="file-thumbnail"]')) return true;
+            var removeBtn = Array.from(document.querySelectorAll('button'))
+                .find(function(b) { return (b.getAttribute('aria-label') || '') === 'Remove'; });
+            return !!removeBtn;
+        })()`);
+        if (ready) return true;
+    }
+    return false;
+}
+
+export async function sendWithFile(page, filePath, prompt) {
+    const fs = await import('node:fs');
+    const path = await import('node:path');
+    const absPath = path.default.resolve(filePath);
+
+    if (!fs.default.existsSync(absPath)) {
+        return { ok: false, reason: `File not found: ${absPath}` };
+    }
+
+    const stats = fs.default.statSync(absPath);
+    if (stats.size > 30 * 1024 * 1024) {
+        return { ok: false, reason: `File too large (${(stats.size / 1024 / 1024).toFixed(1)} MB). Max: 30 MB` };
+    }
+
+    const fileName = path.default.basename(absPath);
+
+    let uploaded = false;
+    if (page.setFileInput) {
+        try {
+            // Upload via CDP so the file content does not cross the daemon body
+            // limit, then trigger React's controlled onChange manually because
+            // CDP assigns .files without firing the synthetic event React listens for.
+            await page.setFileInput([absPath], 'input[data-testid="file-upload"]');
+            const fired = await page.evaluate(`(() => {
+                var inp = document.querySelector('input[data-testid="file-upload"]');
+                if (!inp) return { ok: false, reason: 'file input not found' };
+                var propsKey = Object.keys(inp).find(function(k) { return k.startsWith('__reactProps$'); });
+                if (propsKey && typeof inp[propsKey].onChange === 'function') {
+                    inp[propsKey].onChange({ target: { files: inp.files } });
+                    return { ok: true, via: 'react' };
+                }
+                inp.dispatchEvent(new Event('change', { bubbles: true }));
+                return { ok: true, via: 'native' };
+            })()`);
+            if (!fired?.ok) return fired;
+            uploaded = true;
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (!msg.includes('Unknown action') && !msg.includes('not supported') && !msg.includes('Not allowed')) {
+                throw err;
+            }
+        }
+    }
+
+    if (!uploaded) {
+        const content = fs.default.readFileSync(absPath);
+        const base64 = content.toString('base64');
+        const fallbackResult = await page.evaluate(`(async () => {
+            var binary = atob('${base64}');
+            var bytes = new Uint8Array(binary.length);
+            for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+
+            var file = new File([bytes], ${JSON.stringify(fileName)});
+            var dt = new DataTransfer();
+            dt.items.add(file);
+
+            var inp = document.querySelector('input[data-testid="file-upload"]');
+            if (!inp) return { ok: false, reason: 'file input not found' };
+
+            var propsKey = Object.keys(inp).find(function(k) { return k.startsWith('__reactProps$'); });
+            if (!propsKey || typeof inp[propsKey].onChange !== 'function') {
+                return { ok: false, reason: 'React onChange not found' };
+            }
+
+            inp.files = dt.files;
+            inp[propsKey].onChange({ target: { files: inp.files } });
+            return { ok: true };
+        })()`);
+        if (fallbackResult && !fallbackResult.ok) return fallbackResult;
+    }
+
+    const ready = await waitForFilePreview(page, fileName);
+    if (!ready) return { ok: false, reason: 'file preview did not appear' };
+
+    return sendMessage(page, prompt);
+}
+
+// Retries on CDP "Promise was collected" errors caused by Claude SPA route changes.
+export async function withRetry(fn, retries = 2) {
+    for (let i = 0; i <= retries; i++) {
+        try {
+            return await fn();
+        } catch (err) {
+            const msg = String(err?.message || err);
+            if (i < retries && msg.includes('Promise was collected')) {
+                await new Promise(r => setTimeout(r, 2000));
+                continue;
+            }
+            throw err;
+        }
+    }
+}
+
+export function parseBoolFlag(value) {
+    if (typeof value === 'boolean') return value;
+    return String(value ?? '').trim().toLowerCase() === 'true';
+}

package/clis/claude/utils.test.js

@@ -0,0 +1,148 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { parseBoolFlag, sendWithFile, selectModel, requireConversationId, requireNonEmptyPrompt, requirePositiveInt } from './utils.js';
+
+describe('claude parseBoolFlag', () => {
+    it('returns booleans unchanged', () => {
+        expect(parseBoolFlag(true)).toBe(true);
+        expect(parseBoolFlag(false)).toBe(false);
+    });
+
+    it('treats only "true" string (case-insensitive) as true', () => {
+        expect(parseBoolFlag('true')).toBe(true);
+        expect(parseBoolFlag('TRUE')).toBe(true);
+        expect(parseBoolFlag('1')).toBe(false);
+        expect(parseBoolFlag('yes')).toBe(false);
+        expect(parseBoolFlag('')).toBe(false);
+        expect(parseBoolFlag(null)).toBe(false);
+        expect(parseBoolFlag(undefined)).toBe(false);
+    });
+});
+
+describe('claude argument helpers', () => {
+    it('rejects blank prompts', () => {
+        expect(() => requireNonEmptyPrompt('   ', 'claude ask')).toThrow(ArgumentError);
+    });
+
+    it('rejects non-positive integers for numeric flags', () => {
+        expect(() => requirePositiveInt(0, 'claude ask --timeout')).toThrow(ArgumentError);
+        expect(() => requirePositiveInt(-1, 'claude history --limit')).toThrow(ArgumentError);
+    });
+
+    it('rejects missing conversation ids', () => {
+        expect(() => requireConversationId('   ')).toThrow(ArgumentError);
+    });
+});
+
+describe('claude sendWithFile', () => {
+    const tempDirs = [];
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+        while (tempDirs.length) {
+            fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+        }
+    });
+
+    it('prefers page.setFileInput, then sends after preview appears', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-claude-'));
+        tempDirs.push(dir);
+        const filePath = path.join(dir, 'cat.png');
+        fs.writeFileSync(filePath, 'fake');
+
+        const page = {
+            nativeType: vi.fn().mockResolvedValue(undefined),
+            setFileInput: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true, via: 'react' }) // React onChange fired after setFileInput
+                .mockResolvedValueOnce(true)                       // waitForFilePreview hit
+                .mockResolvedValueOnce(true)                       // composer ready
+                .mockResolvedValueOnce({ ok: true }),              // send button click
+        };
+
+        const result = await sendWithFile(page, filePath, 'describe this');
+
+        expect(result).toEqual({ ok: true });
+        expect(page.setFileInput).toHaveBeenCalledWith([filePath], 'input[data-testid="file-upload"]');
+        expect(page.nativeType).toHaveBeenCalledWith('describe this');
+    });
+
+    it('returns file-not-found when path does not exist', async () => {
+        const page = { setFileInput: vi.fn(), evaluate: vi.fn(), wait: vi.fn() };
+        const result = await sendWithFile(page, '/no/such/file.png', 'hi');
+        expect(result.ok).toBe(false);
+        expect(result.reason).toContain('File not found');
+    });
+
+    it('rejects oversized files before any upload attempt', async () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-claude-'));
+        tempDirs.push(dir);
+        const filePath = path.join(dir, 'big.bin');
+        fs.writeFileSync(filePath, Buffer.alloc(31 * 1024 * 1024));
+
+        const page = { setFileInput: vi.fn(), evaluate: vi.fn(), wait: vi.fn() };
+        const result = await sendWithFile(page, filePath, 'hi');
+
+        expect(result.ok).toBe(false);
+        expect(result.reason).toMatch(/too large/);
+        expect(page.setFileInput).not.toHaveBeenCalled();
+    });
+});
+
+describe('claude selectModel', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    it('rejects unknown model keys without touching the page', async () => {
+        const page = { evaluate: vi.fn() };
+
+        const result = await selectModel(page, 'gpt5');
+
+        expect(result).toEqual({ ok: false });
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('returns toggled=false when the dropdown already shows the requested model', async () => {
+        const page = {
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: true, toggled: false }),
+            wait: vi.fn(),
+        };
+
+        const result = await selectModel(page, 'sonnet');
+
+        expect(result).toEqual({ ok: true, toggled: false });
+        expect(page.wait).not.toHaveBeenCalled();
+    });
+
+    it('opens the dropdown and clicks the matching radio', async () => {
+        const page = {
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true, opened: true })
+                .mockResolvedValueOnce({ ok: true, toggled: true }),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+
+        const result = await selectModel(page, 'haiku');
+
+        expect(result).toEqual({ ok: true, toggled: true });
+        expect(page.evaluate).toHaveBeenCalledTimes(2);
+    });
+
+    it('flags upgrade-required when picking a paid model on free tier', async () => {
+        const page = {
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true, opened: true })
+                .mockResolvedValueOnce({ ok: false, upgrade: true }),
+            wait: vi.fn().mockResolvedValue(undefined),
+        };
+
+        const result = await selectModel(page, 'opus');
+
+        expect(result).toEqual({ ok: false, upgrade: true });
+    });
+});

package/clis/codex/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const askCommand = cli({
     site: 'codex',
     name: 'ask',
@@ -34,7 +34,7 @@ export const askCommand = cli({
       })(${JSON.stringify(text)})
     `);
         if (!injected)
-            throw new SelectorError('Codex input element');
+            throw selectorError('Codex input element');
         await page.wait(0.5);
         await page.pressKey('Enter');
         // Poll for new content

package/clis/codex/send.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const sendCommand = cli({
     site: 'codex',
     name: 'send',
@@ -28,7 +28,7 @@ export const sendCommand = cli({
       })(${JSON.stringify(textToInsert)})
     `);
         if (!injected)
-            throw new SelectorError('Codex Composer input element');
+            throw selectorError('Codex Composer input element');
         // Wait for the UI to register the input
         await page.wait(0.5);
         // Simulate Enter key to submit

package/clis/ctrip/search.js

@@ -34,7 +34,7 @@ cli({
         { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
     ],
     columns: ['rank', 'name', 'type', 'score', 'price', 'url'],
-    func: async (_page, kwargs) => {
+    func: async (kwargs) => {
         const query = String(kwargs.query || '').trim();
         if (!query) {
             throw new ArgumentError('Search keyword cannot be empty');

package/clis/ctrip/search.test.js

@@ -25,7 +25,7 @@ describe('ctrip search', () => {
                 ],
             },
         }), { status: 200 })));
-        const result = await command.func(null, { query: '苏州', limit: 3 });
+        const result = await command.func({ query: '苏州', limit: 3 });
         expect(result).toEqual([
             {
                 rank: 1,
@@ -46,11 +46,11 @@ describe('ctrip search', () => {
         ]);
     });
     it('rejects empty queries', async () => {
-        await expect(command.func(null, { query: '   ', limit: 3 })).rejects.toThrow('Search keyword cannot be empty');
+        await expect(command.func({ query: '   ', limit: 3 })).rejects.toThrow('Search keyword cannot be empty');
     });
     it('surfaces fetch failures as CliError', async () => {
         vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('{}', { status: 503 })));
-        await expect(command.func(null, { query: '苏州', limit: 3 })).rejects.toMatchObject({
+        await expect(command.func({ query: '苏州', limit: 3 })).rejects.toMatchObject({
             code: 'FETCH_ERROR',
             message: 'ctrip search failed with status 503',
         });
@@ -59,6 +59,6 @@ describe('ctrip search', () => {
         vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
             Response: { searchResults: [] },
         }), { status: 200 })));
-        await expect(command.func(null, { query: '苏州', limit: 3 })).rejects.toThrow('ctrip search returned no data');
+        await expect(command.func({ query: '苏州', limit: 3 })).rejects.toThrow('ctrip search returned no data');
     });
 });

package/clis/cursor/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const askCommand = cli({
     site: 'cursor',
     name: 'ask',
@@ -28,7 +28,7 @@ export const askCommand = cli({
         return true;
       })(${JSON.stringify(text)})`);
         if (!injected)
-            throw new SelectorError('Cursor input element');
+            throw selectorError('Cursor input element');
         await page.wait(0.5);
         await page.pressKey('Enter');
         // Poll until a new assistant message appears or timeout