@jackwener/opencli 1.7.12 → 1.7.14

package/clis/stackoverflow/tag.js

@@ -0,0 +1,60 @@
+// stackoverflow tag — list questions tagged with a given tag (most active first).
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import {
+    seFetch,
+    normalizeLimit,
+    requireString,
+    epochToDate,
+    ensureItems,
+    decodeHtmlEntities,
+} from './utils.js';
+
+const SORT_OPTIONS = ['activity', 'votes', 'creation', 'hot', 'week', 'month'];
+
+cli({
+    site: 'stackoverflow',
+    name: 'tag',
+    access: 'read',
+    description: 'List Stack Overflow questions tagged with a given tag (most active first).',
+    domain: 'stackoverflow.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'tag', positional: true, required: true, type: 'string', help: 'Tag slug (e.g. python, rust, typescript).' },
+        { name: 'sort', type: 'string', default: 'activity', help: `Sort key: ${SORT_OPTIONS.join(', ')}` },
+        { name: 'limit', type: 'int', default: 20, help: 'Max questions to return (max 100).' },
+    ],
+    columns: ['rank', 'id', 'title', 'score', 'answers', 'views', 'isAnswered', 'tags', 'author', 'createdAt', 'lastActivityAt', 'url'],
+    func: async (args) => {
+        const tag = requireString(args.tag, 'tag').toLowerCase();
+        const sort = String(args.sort ?? 'activity').toLowerCase();
+        if (!SORT_OPTIONS.includes(sort)) {
+            throw new ArgumentError(`sort must be one of ${SORT_OPTIONS.join(', ')}`);
+        }
+        const limit = normalizeLimit(args.limit, 20, 100, 'limit');
+        const data = await seFetch(`/questions`, {
+            searchParams: {
+                tagged: tag,
+                order: 'desc',
+                sort,
+                pagesize: limit,
+            },
+        });
+        const items = ensureItems(data, `stackoverflow tag "${tag}"`);
+        return items.slice(0, limit).map((q, i) => ({
+            rank: i + 1,
+            id: q.question_id,
+            title: decodeHtmlEntities(q.title || ''),
+            score: q.score ?? 0,
+            answers: q.answer_count ?? 0,
+            views: q.view_count ?? 0,
+            isAnswered: Boolean(q.is_answered),
+            tags: Array.isArray(q.tags) ? q.tags.join(', ') : '',
+            author: decodeHtmlEntities(q.owner?.display_name || ''),
+            createdAt: epochToDate(q.creation_date),
+            lastActivityAt: epochToDate(q.last_activity_date),
+            url: q.link || (q.question_id ? `https://stackoverflow.com/questions/${q.question_id}` : ''),
+        }));
+    },
+});

package/clis/stackoverflow/user.js

@@ -0,0 +1,50 @@
+// stackoverflow user — search Stack Overflow users by name and return profiles.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    seFetch,
+    normalizeLimit,
+    requireString,
+    epochToDate,
+    ensureItems,
+    decodeHtmlEntities,
+} from './utils.js';
+
+cli({
+    site: 'stackoverflow',
+    name: 'user',
+    access: 'read',
+    description: 'Find Stack Overflow users by display name (highest reputation first).',
+    domain: 'stackoverflow.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'name', positional: true, required: true, type: 'string', help: 'Display name (or substring) to search.' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max users to return (max 100).' },
+    ],
+    columns: ['userId', 'displayName', 'reputation', 'goldBadges', 'silverBadges', 'bronzeBadges', 'location', 'createdAt', 'lastAccessAt', 'url'],
+    func: async (args) => {
+        const name = requireString(args.name, 'name');
+        const limit = normalizeLimit(args.limit, 10, 100, 'limit');
+        const data = await seFetch('/users', {
+            searchParams: {
+                inname: name,
+                order: 'desc',
+                sort: 'reputation',
+                pagesize: limit,
+            },
+        });
+        const items = ensureItems(data, 'stackoverflow user');
+        return items.slice(0, limit).map((u) => ({
+            userId: u.user_id,
+            displayName: decodeHtmlEntities(u.display_name || ''),
+            reputation: u.reputation ?? 0,
+            goldBadges: u.badge_counts?.gold ?? 0,
+            silverBadges: u.badge_counts?.silver ?? 0,
+            bronzeBadges: u.badge_counts?.bronze ?? 0,
+            location: decodeHtmlEntities(u.location || ''),
+            createdAt: epochToDate(u.creation_date),
+            lastAccessAt: epochToDate(u.last_access_date),
+            url: u.link || (u.user_id ? `https://stackoverflow.com/users/${u.user_id}` : ''),
+        }));
+    },
+});

package/clis/stackoverflow/utils.js

@@ -0,0 +1,118 @@
+// Shared helpers for stackoverflow adapters using the Stack Exchange API.
+//
+// Public endpoint (api.stackexchange.com 2.3) accepts unauthenticated traffic
+// up to 300 requests/day per IP for read endpoints, plenty for ad-hoc CLI use.
+// We always set `site=stackoverflow` and decode the gzipped/HTML body via the
+// returned JSON envelope.
+import {
+    ArgumentError,
+    CommandExecutionError,
+    EmptyResultError,
+} from '@jackwener/opencli/errors';
+
+export const SE_API = 'https://api.stackexchange.com/2.3';
+export const SE_SITE = 'stackoverflow';
+
+const UA = 'opencli-stackoverflow (+https://github.com/jackwener/opencli)';
+
+/** Validate `limit` per typed-fail-fast convention (no silent clamp). */
+export function normalizeLimit(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const limit = Number(raw);
+    if (!Number.isInteger(limit) || limit <= 0) {
+        throw new ArgumentError(`${label} must be a positive integer`);
+    }
+    if (limit > maxValue) {
+        throw new ArgumentError(`${label} must be <= ${maxValue}`);
+    }
+    return limit;
+}
+
+export function requireString(value, label) {
+    const raw = String(value ?? '').trim();
+    if (!raw) {
+        throw new ArgumentError(`${label} cannot be empty`);
+    }
+    return raw;
+}
+
+/** Fetch a Stack Exchange API endpoint and return parsed JSON envelope. */
+export async function seFetch(path, { searchParams } = {}) {
+    const url = new URL(path.startsWith('http') ? path : `${SE_API}${path.startsWith('/') ? '' : '/'}${path}`);
+    if (searchParams) {
+        for (const [k, v] of Object.entries(searchParams)) {
+            if (v == null || v === '') continue;
+            url.searchParams.set(k, String(v));
+        }
+    }
+    if (!url.searchParams.has('site')) url.searchParams.set('site', SE_SITE);
+
+    let resp;
+    try {
+        resp = await fetch(url, {
+            headers: {
+                'Accept': 'application/json',
+                'Accept-Encoding': 'gzip',
+                'User-Agent': UA,
+            },
+        });
+    } catch (error) {
+        throw new CommandExecutionError(`stack exchange request failed: ${error?.message || error}`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError('stack exchange returned HTTP 429 (rate limited)', 'Wait a few seconds and retry, or lower --limit.');
+    }
+    if (!resp.ok) {
+        let body = '';
+        try { body = (await resp.json())?.error_message || ''; } catch { /* ignore */ }
+        throw new CommandExecutionError(`stack exchange HTTP ${resp.status}: ${body || resp.statusText}`);
+    }
+    let data;
+    try {
+        data = await resp.json();
+    } catch (error) {
+        throw new CommandExecutionError(`stack exchange returned malformed JSON: ${error?.message || error}`);
+    }
+    if (data?.error_id) {
+        throw new CommandExecutionError(
+            `stack exchange API error: ${data.error_message || data.error_name}`,
+            'Inspect the URL in a browser for the canonical error context.',
+        );
+    }
+    return data;
+}
+
+/** Convert SE epoch seconds to YYYY-MM-DD. */
+export function epochToDate(value) {
+    if (value == null || value === '') return '';
+    const n = Number(value);
+    if (!Number.isFinite(n) || n <= 0) return '';
+    return new Date(n * 1000).toISOString().slice(0, 10);
+}
+
+/** Throw EmptyResultError when an /items array is empty. */
+export function ensureItems(data, label) {
+    const items = Array.isArray(data?.items) ? data.items : [];
+    if (items.length === 0) {
+        throw new EmptyResultError(label, `${label} returned no items.`);
+    }
+    return items;
+}
+
+const HTML_ENTITY_MAP = {
+    '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"',
+    '&#39;': "'", '&apos;': "'", '&nbsp;': ' ',
+};
+
+/**
+ * Decode the small set of HTML entities Stack Exchange emits in display
+ * names and titles (e.g. "Jon Skeet&#39;s mentor"). Decimal/hex numeric
+ * refs are also handled.
+ */
+export function decodeHtmlEntities(value) {
+    if (value == null) return '';
+    return String(value)
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&(amp|lt|gt|quot|#39|apos|nbsp);/g, (m) => HTML_ENTITY_MAP[m] || m);
+}

package/clis/steam/app.js

@@ -0,0 +1,67 @@
+// steam app — fetch a single Steam game / DLC / app's storefront detail.
+//
+// Hits the public appdetails API (`/api/appdetails?appids=<id>`). Surfaces
+// the columns most useful for an agent: name, type, free flag, release
+// date, developers / publishers, price, metacritic, recommendations,
+// genres / categories joined.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { STEAM_STORE, decodeHtmlEntities, priceCents, requireAppId, requireCountryCode, steamFetch } from './utils.js';
+
+function joinNames(list) {
+    if (!Array.isArray(list)) return '';
+    return list
+        .map((entry) => (entry && typeof entry === 'object' ? entry.description ?? entry.name ?? '' : String(entry)))
+        .filter(Boolean)
+        .join(', ');
+}
+
+cli({
+    site: 'steam',
+    name: 'app',
+    access: 'read',
+    description: 'Steam storefront detail for a single app id',
+    domain: 'store.steampowered.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Numeric Steam app id (e.g. "620" for Portal 2)' },
+        { name: 'currency', default: 'us', help: 'Storefront country code (e.g. us / cn / jp / de)' },
+    ],
+    columns: [
+        'id', 'name', 'type', 'isFree', 'releaseDate', 'developers', 'publishers',
+        'price', 'currency', 'metacritic', 'recommendations', 'genres', 'categories',
+        'shortDescription', 'website', 'url',
+    ],
+    func: async (args) => {
+        const appId = requireAppId(args.id);
+        const cc = requireCountryCode(args.currency);
+        const url = `${STEAM_STORE}/api/appdetails?appids=${appId}&l=en&cc=${encodeURIComponent(cc)}`;
+        const body = await steamFetch(url, `steam app ${appId}`);
+        const wrapper = body?.[appId];
+        if (!wrapper || wrapper.success !== true || !wrapper.data) {
+            throw new EmptyResultError('steam app', `Steam app id ${appId} returned no data (may be region-locked or removed).`);
+        }
+        const data = wrapper.data;
+        const isFree = data.is_free === true;
+        const priceFinal = priceCents(data?.price_overview?.final ?? null);
+        return [{
+            id: String(data.steam_appid ?? appId),
+            name: decodeHtmlEntities(data.name ?? ''),
+            type: String(data.type ?? ''),
+            isFree,
+            releaseDate: String(data?.release_date?.date ?? ''),
+            developers: Array.isArray(data.developers) ? data.developers.join(', ') : '',
+            publishers: Array.isArray(data.publishers) ? data.publishers.join(', ') : '',
+            price: isFree ? 0 : priceFinal,
+            currency: String(data?.price_overview?.currency ?? '').toUpperCase(),
+            metacritic: data?.metacritic?.score != null ? Number(data.metacritic.score) : null,
+            recommendations: data?.recommendations?.total != null ? Number(data.recommendations.total) : null,
+            genres: joinNames(data.genres),
+            categories: joinNames(data.categories),
+            shortDescription: decodeHtmlEntities(data.short_description ?? ''),
+            website: String(data.website ?? ''),
+            url: `${STEAM_STORE}/app/${data.steam_appid ?? appId}/`,
+        }];
+    },
+});

package/clis/steam/search.js

@@ -0,0 +1,58 @@
+// steam search — search the Steam storefront catalog.
+//
+// Hits the public storesearch API (`/api/storesearch/?term=…`). Returns
+// matched apps with id / name / price / metascore / platform support so
+// the row's `id` round-trips into `steam app`.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    STEAM_STORE,
+    decodeHtmlEntities,
+    priceCents,
+    requireBoundedInt,
+    requireCountryCode,
+    requireString,
+    steamFetch,
+} from './utils.js';
+
+function platformList(platforms) {
+    if (!platforms || typeof platforms !== 'object') return '';
+    return ['windows', 'mac', 'linux'].filter((p) => platforms[p]).join(',');
+}
+
+cli({
+    site: 'steam',
+    name: 'search',
+    access: 'read',
+    description: 'Search the Steam storefront by name keyword',
+    domain: 'store.steampowered.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "portal", "stardew")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-50)' },
+        { name: 'currency', default: 'us', help: 'Storefront country code (e.g. us / cn / jp / de)' },
+    ],
+    columns: ['rank', 'id', 'name', 'price', 'currency', 'metascore', 'platforms', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 50);
+        const cc = requireCountryCode(args.currency);
+        const url = `${STEAM_STORE}/api/storesearch/?term=${encodeURIComponent(query)}&l=en&cc=${encodeURIComponent(cc)}`;
+        const body = await steamFetch(url, 'steam search');
+        const items = Array.isArray(body?.items) ? body.items : [];
+        if (!items.length) {
+            throw new EmptyResultError('steam search', `No Steam results matched "${query}".`);
+        }
+        return items.slice(0, limit).map((item, i) => ({
+            rank: i + 1,
+            id: String(item.id ?? ''),
+            name: decodeHtmlEntities(item.name ?? ''),
+            price: priceCents(item?.price?.final ?? null),
+            currency: String(item?.price?.currency ?? '').toUpperCase(),
+            metascore: item.metascore != null && item.metascore !== '' ? Number(item.metascore) : null,
+            platforms: platformList(item.platforms),
+            url: item.id ? `${STEAM_STORE}/app/${item.id}/` : '',
+        }));
+    },
+});

package/clis/steam/steam.test.js

@@ -0,0 +1,46 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { decodeHtmlEntities, requireCountryCode } from './utils.js';
+import './search.js';
+import './app.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+});
+
+describe('steam adapter helpers', () => {
+    it('decodes Steam HTML entities from API strings', () => {
+        expect(decodeHtmlEntities('"Perpetual Testing Initiative" & Co-op')).toBe('"Perpetual Testing Initiative" & Co-op');
+        expect(decodeHtmlEntities('Portal 2')).toBe('Portal 2');
+    });
+
+    it('validates storefront country code without silent fallback', () => {
+        expect(requireCountryCode(undefined)).toBe('us');
+        expect(requireCountryCode(' CN ')).toBe('cn');
+        expect(() => requireCountryCode('')).toThrow(ArgumentError);
+        expect(() => requireCountryCode('usd')).toThrow(ArgumentError);
+        expect(() => requireCountryCode('$$')).toThrow(ArgumentError);
+    });
+});
+
+describe('steam command argument contracts', () => {
+    it('rejects invalid search currency before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        const search = getRegistry().get('steam/search');
+        await expect(search.func({ query: 'portal', limit: 5, currency: '$$$' })).rejects.toThrow(ArgumentError);
+        await expect(search.func({ query: 'portal', limit: 5, currency: '' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('rejects invalid app currency before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        const app = getRegistry().get('steam/app');
+        await expect(app.func({ id: '620', currency: 'usd' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+});

package/clis/steam/utils.js

@@ -0,0 +1,107 @@
+// Shared helpers for the steam adapters that hit Steam's storefront JSON
+// endpoints (no browser).
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const STEAM_STORE = 'https://store.steampowered.com';
+const UA = 'opencli-steam-adapter (+https://github.com/jackwener/opencli)';
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) {
+        throw new ArgumentError(`steam ${label} cannot be empty`);
+    }
+    return s;
+}
+
+export function requireCountryCode(value, defaultValue = 'us') {
+    const raw = value === undefined || value === null ? defaultValue : value;
+    const code = String(raw).trim().toLowerCase();
+    if (!/^[a-z]{2}$/.test(code)) {
+        throw new ArgumentError(
+            `steam currency must be a two-letter storefront country code (got "${value}")`,
+            'Examples: us, cn, jp, de. This controls Steam regional pricing and availability.',
+        );
+    }
+    return code;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`steam ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`steam ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export function requireAppId(value) {
+    const s = String(value ?? '').trim();
+    if (!s) {
+        throw new ArgumentError('steam app id is required (e.g. "620" for Portal 2)');
+    }
+    if (!/^\d+$/.test(s)) {
+        throw new ArgumentError(
+            `steam app id "${value}" must be a positive integer`,
+            'Copy the numeric id from `steam search` or the URL `store.steampowered.com/app/<id>/`.',
+        );
+    }
+    return s;
+}
+
+export async function steamFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that store.steampowered.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'Steam throttles bursty traffic; wait a few seconds and retry.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, 'Steam returned 404 — the resource does not exist.');
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+export function asString(value) {
+    return value == null ? '' : String(value);
+}
+
+const HTML_ENTITIES = {
+    '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'", '&#39;': "'", '&nbsp;': ' ',
+};
+
+export function decodeHtmlEntities(value) {
+    return String(value ?? '')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&(amp|lt|gt|quot|apos|#39|nbsp);/g, (m) => HTML_ENTITIES[m] || m);
+}
+
+export function priceCents(cents) {
+    if (cents == null || cents === '') return null;
+    const n = Number(cents);
+    if (!Number.isFinite(n)) return null;
+    return Number((n / 100).toFixed(2));
+}

package/clis/taobao/commands.test.js

@@ -5,30 +5,7 @@ import './detail.js';
 import './reviews.js';
 import './cart.js';
 import './add-cart.js';
-function createPageMock() {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue({ title: 'Demo', price: '¥99' }),
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        getCookies: vi.fn().mockResolvedValue([]),
-        screenshot: vi.fn().mockResolvedValue(''),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-    };
-}
+import { createPageMock } from '../test-utils.js';
 describe('taobao command registration', () => {
     it('registers all taobao shopping commands', () => {
         for (const name of ['search', 'detail', 'reviews', 'cart', 'add-cart']) {

package/clis/test-utils.js

@@ -0,0 +1,61 @@
+import { vi } from 'vitest';
+
+/**
+ * Create a page mock with all standard browser automation methods.
+ *
+ * @param {any[]} evaluateResults - Sequential results for page.evaluate() calls
+ * @param {Record<string, any>} [overrides] - Override or add mock methods
+ * @returns A mock page object compatible with OpenCLI's browser page interface
+ */
+export function createPageMock(evaluateResults = [], overrides = {}) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        // Navigation
+        goto: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+
+        // Content extraction
+        evaluate,
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        screenshot: vi.fn().mockResolvedValue(''),
+
+        // User interaction
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+
+        // Form handling
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+
+        // Monitoring
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+
+        // Request interception
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        waitForCapture: vi.fn().mockResolvedValue(undefined),
+
+        // Network capture
+        startNetworkCapture: vi.fn().mockResolvedValue(undefined),
+        readNetworkCapture: vi.fn().mockResolvedValue([]),
+
+        // Auth
+        getCookies: vi.fn().mockResolvedValue([]),
+
+        // Wait
+        wait: vi.fn().mockResolvedValue(undefined),
+
+        ...overrides,
+    };
+}

package/clis/tieba/hot.js

@@ -9,7 +9,6 @@ cli({
     domain: 'tieba.baidu.com',
     strategy: Strategy.PUBLIC,
     browser: true,
-    navigateBefore: false,
     args: [
         { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
     ],