@agentrhq/webcmd 0.1.2 → 0.2.1

package/clis/xianyu/publish.test.js

@@ -1,220 +0,0 @@
-import { JSDOM } from 'jsdom';
-import { describe, it, expect, vi } from 'vitest';
-import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
-
-vi.mock('node:fs', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        statSync: vi.fn((input) => {
-            const value = String(input);
-            if (value.includes('missing')) return undefined;
-            return { isFile: () => !value.includes('directory') };
-        }),
-    };
-});
-
-vi.mock('node:path', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        resolve: vi.fn((input) => `/abs/${input}`),
-        extname: vi.fn((input) => {
-            const match = String(input).match(/\.[^.]+$/);
-            return match ? match[0] : '';
-        }),
-    };
-});
-
-import { __test__, publishCommand } from './publish.js';
-
-function makePage({ evaluateResults = [], overrides = {} } = {}) {
-    const evaluate = vi.fn();
-    for (const result of evaluateResults) {
-        evaluate.mockResolvedValueOnce(result);
-    }
-    evaluate.mockResolvedValue({ ok: false, reason: 'unknown-state' });
-
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate,
-        setFileInput: vi.fn().mockResolvedValue(undefined),
-        getCurrentUrl: vi.fn().mockResolvedValue('https://www.goofish.com/publish'),
-        ...overrides,
-    };
-}
-
-async function runBrowserScript(html, script, { url = 'https://www.goofish.com/publish' } = {}) {
-    const dom = new JSDOM(html, { url, runScripts: 'outside-only' });
-    return dom.window.eval(script);
-}
-
-const validArgs = {
-    title: 'MacBook Pro',
-    description: '成色很好，功能正常',
-    price: '5999.99',
-    condition: '轻微使用',
-    category: '笔记本',
-};
-
-describe('xianyu/publish', () => {
-    it('builds the goofish publish URL', () => {
-        expect(__test__.buildPublishUrl()).toBe('https://www.goofish.com/publish');
-    });
-
-    it('validates publish arguments before navigation', async () => {
-        const page = makePage();
-
-        await expect(publishCommand.func(page, { ...validArgs, title: '   ' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, price: '0' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, price: '12.345' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, condition: '八成新' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, images: 'a.bmp' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, images: 'missing.png' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(publishCommand.func(page, { ...validArgs, images: '1.png,2.png,3.png,4.png,5.png,6.png,7.png,8.png,9.png,10.png' })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-
-    it('publishes when every UI step has positive proof', async () => {
-        const page = makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: true, filled: ['title', 'description', 'price', 'condition'], missing: [] },
-                { ok: true },
-                { status: 'published', item_id: '123456789012', url: 'https://www.goofish.com/item?id=123456789012' },
-            ],
-        });
-
-        const rows = await publishCommand.func(page, validArgs);
-
-        expect(rows).toEqual([{
-            status: 'published',
-            item_id: '123456789012',
-            title: 'MacBook Pro',
-            price: '¥5999.99',
-            condition: '轻微使用',
-            url: 'https://www.goofish.com/item?id=123456789012',
-            message: '发布成功',
-        }]);
-    });
-
-    it('uses IPage getCurrentUrl instead of a non-existent page.url method', async () => {
-        const page = makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: true, filled: ['title', 'description', 'price', 'condition'], missing: [] },
-                { ok: true },
-                { status: 'published', item_id: '123456789012' },
-            ],
-            overrides: {
-                getCurrentUrl: vi.fn().mockResolvedValue('https://www.goofish.com/item?id=123456789012'),
-            },
-        });
-
-        expect(page.url).toBeUndefined();
-
-        const rows = await publishCommand.func(page, validArgs);
-
-        expect(page.getCurrentUrl).toHaveBeenCalled();
-        expect(rows[0].url).toBe('https://www.goofish.com/item?id=123456789012');
-    });
-
-    it('maps login walls to AuthRequiredError', async () => {
-        const page = makePage({
-            evaluateResults: [
-                { requiresAuth: true },
-            ],
-        });
-
-        await expect(publishCommand.func(page, validArgs)).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('fails fast when category selection or form filling is not proven', async () => {
-        await expect(publishCommand.func(makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: false, reason: 'category-not-found' },
-            ],
-        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
-
-        await expect(publishCommand.func(makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: false, missing: ['price'] },
-            ],
-        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('uploads validated local images through the discovered file input', async () => {
-        const page = makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: true, missing: [] },
-                { ok: true, selector: '[id="upload"]' },
-                { ok: true },
-                { status: 'published', item_id: '123456789012', url: 'https://www.goofish.com/item?id=123456789012' },
-            ],
-        });
-
-        await publishCommand.func(page, { ...validArgs, images: 'a.png,b.webp' });
-
-        expect(page.setFileInput).toHaveBeenCalledWith(['/abs/a.png', '/abs/b.webp'], '[id="upload"]');
-    });
-
-    it('does not return a success row for failed or unconfirmed publish states', async () => {
-        await expect(publishCommand.func(makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: true, missing: [] },
-                { ok: true },
-                { status: 'failed', message: '内容违规' },
-            ],
-        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
-
-        await expect(publishCommand.func(makePage({
-            evaluateResults: [
-                { hasPublishForm: true },
-                { ok: true },
-                { ok: true, missing: [] },
-                { ok: true },
-            ],
-        }), validArgs)).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('browser category script is async and returns typed failure reasons', async () => {
-        const result = await runBrowserScript('<main><button>其他</button></main>', __test__.buildSelectCategoryEvaluate('笔记本'));
-
-        expect(result).toEqual({ ok: false, reason: 'category-trigger-not-found' });
-    });
-
-    it('browser fill script reports missing required fields', async () => {
-        const result = await runBrowserScript(`
-            <main>
-              <input placeholder="标题" />
-              <textarea id="desc"></textarea>
-              <button>轻微使用</button>
-            </main>
-        `, __test__.buildFillFormEvaluate(validArgs));
-
-        expect(result.ok).toBe(false);
-        expect(result.missing).toContain('price');
-    });
-
-    it('browser success detector distinguishes success from failure and unknown states', async () => {
-        await expect(runBrowserScript('<body>发布成功</body>', __test__.buildDetectSuccessEvaluate(), {
-            url: 'https://www.goofish.com/item?id=123456789012',
-        })).resolves.toMatchObject({ status: 'published', item_id: '123456789012' });
-
-        await expect(runBrowserScript('<body><div class="error">内容违规</div></body>', __test__.buildDetectSuccessEvaluate()))
-            .resolves.toMatchObject({ status: 'failed', message: '内容违规' });
-
-        await expect(runBrowserScript('<body>处理中</body>', __test__.buildDetectSuccessEvaluate()))
-            .resolves.toEqual({ ok: false, reason: 'unknown-state' });
-    });
-});

package/clis/xianyu/reply.js

@@ -1,82 +0,0 @@
-import { ArgumentError, AuthRequiredError, CommandExecutionError, selectorError } from '@agentrhq/webcmd/errors';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { buildChatUrl, buildClickInboxConversationEvaluate, buildExtractChatStateEvaluate, buildSendMessageEvaluate, normalizeRank, requireClickResult, requireEvaluateObject, requireText } from './im.js';
-import { normalizeNumericId } from './utils.js';
-
-cli({
-    site: 'xianyu',
-    name: 'reply',
-    access: 'write',
-    description: '回复指定闲鱼私信会话',
-    domain: 'www.goofish.com',
-    strategy: Strategy.COOKIE,
-    navigateBefore: false,
-    browser: true,
-    args: [
-        { name: 'item_id', positional: true, help: '闲鱼商品 item_id' },
-        { name: 'user_id', positional: true, help: '聊一聊对方的 user_id / peerUserId' },
-        { name: 'text', required: true, help: 'Message text to send' },
-        { name: 'rank', type: 'int', default: 0, help: 'Conversation rank from xianyu inbox; clicks the visible row instead of requiring IDs' },
-    ],
-    columns: ['status', 'peer_name', 'item_title', 'price', 'location', 'message'],
-    func: async (page, kwargs) => {
-        const hasItemId = kwargs.item_id != null && kwargs.item_id !== '';
-        const hasUserId = kwargs.user_id != null && kwargs.user_id !== '';
-        const rank = normalizeRank(kwargs.rank);
-        if (rank > 0 && (hasItemId || hasUserId)) {
-            throw new ArgumentError('xianyu reply accepts either item_id/user_id or --rank, not both');
-        }
-        if (rank === 0 && hasItemId !== hasUserId) {
-            throw new ArgumentError('xianyu reply requires both item_id and user_id, or --rank from xianyu inbox');
-        }
-        if (rank === 0 && !hasItemId && !hasUserId) {
-            throw new ArgumentError('xianyu reply requires item_id/user_id or --rank from xianyu inbox');
-        }
-        const hasIds = hasItemId && hasUserId;
-        const itemId = hasIds ? normalizeNumericId(kwargs.item_id, 'item_id', '1038951278192') : '';
-        const userId = hasIds ? normalizeNumericId(kwargs.user_id, 'user_id', '3650092411') : '';
-        const text = requireText(kwargs.text, 'xianyu reply --text');
-        const url = hasIds ? buildChatUrl(itemId, userId) : '';
-        if (hasIds) {
-            await page.goto(url);
-        } else {
-            if (!page.getCurrentUrl || !/https:\/\/www\.goofish\.com\/im\b/.test(await page.getCurrentUrl())) {
-                await page.goto('https://www.goofish.com/im');
-            }
-        }
-        await page.wait(2);
-        if (rank > 0) {
-            requireClickResult(await page.evaluate(buildClickInboxConversationEvaluate(rank - 1)), 'reply rank click');
-            await page.wait(2);
-        }
-        const state = requireEvaluateObject(await page.evaluate(buildExtractChatStateEvaluate()), 'reply');
-        if (state?.requiresAuth) {
-            throw new AuthRequiredError('www.goofish.com', 'Xianyu reply requires a logged-in browser session');
-        }
-        if (!state?.can_input) {
-            throw selectorError('闲鱼聊天输入框', '未找到可用的聊天输入框，请确认该会话页已正确加载');
-        }
-        const sent = requireEvaluateObject(await page.evaluate(buildSendMessageEvaluate(text)), 'reply send');
-        if (!sent?.ok) {
-            throw new CommandExecutionError(`Xianyu reply did not observe the sent message: ${sent?.reason || 'unknown-reason'}`);
-        }
-        await page.wait(1);
-        return [{
-            status: 'sent',
-            peer_name: state.peer_name || '',
-            item_title: state.item_title || '',
-            price: state.price || '',
-            location: state.location || '',
-            message: text,
-            peer_user_id: userId,
-            item_id: itemId,
-            url: url || '',
-            item_url: state.item_url || '',
-        }];
-    },
-});
-
-export const __test__ = {
-    buildChatUrl,
-    buildSendMessageEvaluate,
-};

package/clis/xianyu/search.js

@@ -1,262 +0,0 @@
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError, selectorError } from '@agentrhq/webcmd/errors';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-const ROWS_PER_PAGE = 30;
-const MAX_LIMIT = 60;
-function normalizeLimit(value) {
-    const n = Number(value);
-    if (!Number.isFinite(n))
-        return 20;
-    return Math.min(MAX_LIMIT, Math.max(1, Math.floor(n)));
-}
-function buildSearchUrl(query) {
-    return `https://www.goofish.com/search?q=${encodeURIComponent(query)}`;
-}
-// Parse a --min-price / --max-price argument into a non-negative number, or null when omitted.
-// (`float` args are not auto-coerced by the framework, so they arrive as strings.)
-function parsePriceArg(value, label) {
-    if (value === undefined || value === null || value === '')
-        return null;
-    const n = Number(String(value).trim());
-    if (!Number.isFinite(n) || n < 0) {
-        throw new ArgumentError(`xianyu search ${label} must be a non-negative number`, `For example: --${label} 100000`);
-    }
-    return n;
-}
-// Goofish's PC search applies price filtering server-side via
-// propValueStr.searchFilter = "priceRange:<min>,<max>;" (values in 元). An omitted
-// bound is filled with a wide default so a single-sided range still works.
-function buildSearchFilter(minPrice, maxPrice) {
-    if (minPrice == null && maxPrice == null)
-        return '';
-    const lo = minPrice != null ? minPrice : 0;
-    const hi = maxPrice != null ? maxPrice : 99999999;
-    return `priceRange:${lo},${hi};`;
-}
-// Region filtering is server-side via extraFilterValue (a JSON string) carrying a
-// divisionList of {province, city} pairs. A city alone (empty province) is accepted,
-// as is a province alone (empty city). Returns "{}" when no region is requested.
-function buildExtraFilterValue(province, city) {
-    if (!province && !city)
-        return '{}';
-    return JSON.stringify({
-        divisionList: [{ province: province || '', city: city || '' }],
-        excludeMultiPlacesSellers: '0',
-        extraDivision: '',
-    });
-}
-function buildSearchEvaluate({ keyword, searchFilter, extraFilterValue, fromFilter, maxItems }) {
-    return `
-    (async () => {
-      const clean = (value) => String(value ?? '').replace(/\\s+/g, ' ').trim();
-      const cleanFirst = (...values) => values.map(clean).find(Boolean) || '';
-      const cleanTagList = (value) => {
-        const nodes = Array.isArray(value) ? value : [];
-        return nodes
-          .map((entry) => cleanFirst(entry?.text, entry?.title, entry?.name, entry?.label, entry?.content, entry?.data?.content))
-          .filter(Boolean)
-          .join(' | ');
-      };
-      const extractRetCode = (ret) => {
-        const first = Array.isArray(ret) ? ret[0] : '';
-        return clean(first).split('::')[0] || '';
-      };
-      const waitFor = async (predicate, timeoutMs = 6000) => {
-        const start = Date.now();
-        while (Date.now() - start < timeoutMs) {
-          if (predicate()) return true;
-          await new Promise((r) => setTimeout(r, 150));
-        }
-        return false;
-      };
-
-      const bodyText = document.body?.innerText || '';
-      if (/请先登录|扫码登录|登录后/.test(bodyText)) return { error: 'auth-required' };
-      if (/验证码|安全验证|异常访问/.test(bodyText)) return { error: 'blocked' };
-
-      await waitFor(() => window.lib?.mtop?.request);
-      if (!window.lib || !window.lib.mtop || typeof window.lib.mtop.request !== 'function') {
-        return { error: 'mtop-not-ready' };
-      }
-
-      const searchFilter = ${JSON.stringify(searchFilter)};
-      const propValueStr = searchFilter ? { searchFilter } : {};
-      const rows = ${ROWS_PER_PAGE};
-      const maxItems = ${maxItems};
-      const maxPages = Math.ceil(maxItems / rows);
-      const collected = [];
-
-      for (let page = 1; page <= maxPages && collected.length < maxItems; page++) {
-        let response;
-        try {
-          response = await window.lib.mtop.request({
-            api: 'mtop.taobao.idlemtopsearch.pc.search',
-            data: {
-              pageNumber: page,
-              keyword: ${JSON.stringify(keyword)},
-              fromFilter: ${fromFilter ? 'true' : 'false'},
-              rowsPerPage: rows,
-              sortValue: '',
-              sortField: '',
-              customDistance: '',
-              gps: '',
-              propValueStr,
-              customGps: '',
-              searchReqFromPage: 'pcSearch',
-              extraFilterValue: ${JSON.stringify(extraFilterValue)},
-              userPositionJson: '{}',
-            },
-            type: 'POST',
-            v: '1.0',
-            dataType: 'json',
-            needLogin: false,
-            needLoginPC: false,
-            sessionOption: 'AutoLoginOnly',
-            ecode: 0,
-          });
-        } catch (error) {
-          const ret = error?.ret || [];
-          return {
-            error: 'mtop-request-failed',
-            error_code: extractRetCode(ret),
-            error_message: clean(Array.isArray(ret) ? ret.join(' | ') : error?.message || error),
-          };
-        }
-
-        const retCode = extractRetCode(response?.ret || []);
-        if (retCode && retCode !== 'SUCCESS') {
-          return {
-            error: 'mtop-response-error',
-            error_code: retCode,
-            error_message: clean((response?.ret || []).join(' | ')),
-          };
-        }
-
-        if (!response?.data || !Array.isArray(response.data.resultList)) {
-          return {
-            error: 'malformed-response',
-            error_message: 'Xianyu search response did not include a resultList array',
-          };
-        }
-
-        const list = response.data.resultList;
-        if (!list.length) break;
-
-        let pageValidRows = 0;
-        let pageMalformedRows = 0;
-        for (const entry of list) {
-          const itemNode = entry?.data?.item || {};
-          const main = itemNode.main || {};
-          const args = main.clickParam?.args || {};
-          const ex = main.exContent || itemNode.exContent || {};
-          const itemId = clean(args.item_id || args.id || '');
-          const title = clean(ex.title || ex.detailParams?.title || '');
-          if (!itemId || !title) {
-            pageMalformedRows += 1;
-            continue;
-          }
-          const priceYuan = clean(args.price || args.displayPrice || '');
-          const city = clean(args.p_city || '');
-          const area = clean(ex.area || '');
-          const tagText = cleanTagList(ex.fishTags || ex.labels || ex.tags || ex.tagList || []);
-          collected.push({
-            item_id: itemId,
-            title,
-            price: priceYuan ? ('¥' + priceYuan) : '',
-            condition: cleanFirst(ex.condition, ex.stuffStatus, ex.detailParams?.condition),
-            brand: cleanFirst(ex.brand, ex.brandName, ex.detailParams?.brand),
-            location: city || area,
-            badge: cleanFirst(ex.badge, ex.creditText, ex.creditLevel, tagText),
-            want: clean(args.wantNum || ex.want || ''),
-            url: 'https://www.goofish.com/item?id=' + itemId,
-          });
-          pageValidRows += 1;
-          if (collected.length >= maxItems) break;
-        }
-
-        if (!pageValidRows && pageMalformedRows) {
-          return {
-            error: 'malformed-row',
-            error_message: 'Xianyu search result rows were missing item_id or title',
-          };
-        }
-
-        if (list.length < rows) break;
-      }
-
-      return { items: collected };
-    })()
-  `;
-}
-cli({
-    site: 'xianyu',
-    name: 'search',
-    access: 'read',
-    description: '搜索闲鱼商品（支持服务端价格区间 / 地区筛选）',
-    domain: 'www.goofish.com',
-    strategy: Strategy.COOKIE,
-    navigateBefore: false,
-    browser: true,
-    args: [
-        { name: 'query', required: true, positional: true, help: '搜索关键词' },
-        { name: 'limit', type: 'int', default: 20, help: `返回结果数（最多 ${MAX_LIMIT}，自动翻页）` },
-        { name: 'min-price', type: 'float', help: '最低价格（元），服务端筛选' },
-        { name: 'max-price', type: 'float', help: '最高价格（元），服务端筛选' },
-        { name: 'province', type: 'string', help: '省份名（如 广东），服务端按地区筛选' },
-        { name: 'city', type: 'string', help: '城市名（如 深圳 / 湛江），可单独使用，服务端按地区筛选' },
-    ],
-    columns: ['item_id', 'rank', 'title', 'price', 'condition', 'brand', 'location', 'badge', 'want', 'url'],
-    func: async (page, kwargs) => {
-        const query = String(kwargs.query || '').trim();
-        const limit = normalizeLimit(kwargs.limit);
-        const minPrice = parsePriceArg(kwargs['min-price'], 'min-price');
-        const maxPrice = parsePriceArg(kwargs['max-price'], 'max-price');
-        if (minPrice != null && maxPrice != null && minPrice > maxPrice) {
-            throw new ArgumentError('xianyu search min-price cannot be greater than max-price', `Received --min-price ${minPrice} and --max-price ${maxPrice}`);
-        }
-        const province = String(kwargs.province || '').trim();
-        const city = String(kwargs.city || '').trim();
-        const searchFilter = buildSearchFilter(minPrice, maxPrice);
-        const extraFilterValue = buildExtraFilterValue(province, city);
-        const fromFilter = Boolean(searchFilter) || extraFilterValue !== '{}';
-        await page.goto(buildSearchUrl(query));
-        await page.wait(2);
-        const result = await page.evaluate(buildSearchEvaluate({ keyword: query, searchFilter, extraFilterValue, fromFilter, maxItems: limit }));
-        if (result?.error === 'auth-required') {
-            throw new AuthRequiredError('www.goofish.com', 'Xianyu search requires a logged-in browser session');
-        }
-        if (result?.error === 'blocked') {
-            throw new CommandExecutionError('Xianyu returned a verification page or blocked the current browser session');
-        }
-        if (result?.error === 'mtop-not-ready') {
-            throw selectorError('window.lib.mtop', '闲鱼页面未完成初始化，无法调用搜索接口');
-        }
-        if (!result || typeof result !== 'object') {
-            throw new CommandExecutionError('Xianyu search returned a malformed response');
-        }
-        const errorCode = String(result?.error_code || '');
-        const errorMessage = String(result?.error_message || '');
-        if (/FAIL_SYS_SESSION_EXPIRED|SESSION_EXPIRED|FAIL_SYS_TOKEN/.test(errorCode) || /FAIL_SYS_SESSION_EXPIRED|SESSION_EXPIRED/.test(errorMessage)) {
-            throw new AuthRequiredError('www.goofish.com', 'Xianyu search requires a logged-in browser session');
-        }
-        if (result?.error) {
-            throw new CommandExecutionError(errorMessage || `Xianyu search request failed: ${result.error}`);
-        }
-        if (!Array.isArray(result.items)) {
-            throw new CommandExecutionError('Xianyu search response did not include an items array');
-        }
-        const items = result.items;
-        if (!items.length) {
-            throw new EmptyResultError('xianyu search', '没有匹配的商品（筛选条件可能过窄，或当前关键词无结果）');
-        }
-        return items.map((item, index) => ({ rank: index + 1, ...item }));
-    },
-});
-export const __test__ = {
-    ROWS_PER_PAGE,
-    MAX_LIMIT,
-    normalizeLimit,
-    buildSearchUrl,
-    parsePriceArg,
-    buildSearchFilter,
-    buildExtraFilterValue,
-};

package/clis/xianyu/search.test.js

@@ -1,104 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
-import { getRegistry } from '@agentrhq/webcmd/registry';
-import { __test__ } from './search.js';
-import './search.js';
-describe('xianyu search helpers', () => {
-    it('normalizes limit into supported range', () => {
-        expect(__test__.normalizeLimit(undefined)).toBe(20);
-        expect(__test__.normalizeLimit(0)).toBe(1);
-        expect(__test__.normalizeLimit(3.8)).toBe(3);
-        expect(__test__.normalizeLimit(999)).toBe(__test__.MAX_LIMIT);
-    });
-    it('builds search URLs with encoded queries', () => {
-        expect(__test__.buildSearchUrl('小鹏G9')).toBe('https://www.goofish.com/search?q=%E5%B0%8F%E9%B9%8FG9');
-    });
-});
-describe('xianyu search price filter', () => {
-    it('parses price arguments, returning null when omitted', () => {
-        expect(__test__.parsePriceArg(undefined, 'min-price')).toBeNull();
-        expect(__test__.parsePriceArg('', 'min-price')).toBeNull();
-        expect(__test__.parsePriceArg('100000', 'min-price')).toBe(100000);
-        expect(__test__.parsePriceArg(200000.5, 'max-price')).toBe(200000.5);
-    });
-    it('rejects negative or non-numeric price arguments', () => {
-        expect(() => __test__.parsePriceArg('-1', 'min-price')).toThrow(ArgumentError);
-        expect(() => __test__.parsePriceArg('abc', 'max-price')).toThrow(ArgumentError);
-    });
-    it('encodes priceRange the way goofish expects, filling open-ended bounds', () => {
-        expect(__test__.buildSearchFilter(null, null)).toBe('');
-        expect(__test__.buildSearchFilter(100000, 200000)).toBe('priceRange:100000,200000;');
-        expect(__test__.buildSearchFilter(100000, null)).toBe('priceRange:100000,99999999;');
-        expect(__test__.buildSearchFilter(null, 200000)).toBe('priceRange:0,200000;');
-    });
-});
-describe('xianyu search region filter', () => {
-    it('returns {} when no region is requested', () => {
-        expect(__test__.buildExtraFilterValue('', '')).toBe('{}');
-    });
-    it('encodes a city alone (empty province)', () => {
-        expect(JSON.parse(__test__.buildExtraFilterValue('', '深圳'))).toEqual({
-            divisionList: [{ province: '', city: '深圳' }],
-            excludeMultiPlacesSellers: '0',
-            extraDivision: '',
-        });
-    });
-    it('encodes a province alone, and a province+city pair', () => {
-        expect(JSON.parse(__test__.buildExtraFilterValue('广东', '')).divisionList).toEqual([{ province: '广东', city: '' }]);
-        expect(JSON.parse(__test__.buildExtraFilterValue('广东', '湛江')).divisionList).toEqual([{ province: '广东', city: '湛江' }]);
-    });
-});
-function createPageMock(evaluateResult) {
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        wait: vi.fn().mockResolvedValue(undefined),
-        evaluate: vi.fn().mockResolvedValue(evaluateResult),
-    };
-}
-describe('xianyu search command', () => {
-    const command = getRegistry().get('xianyu/search');
-    it('keeps existing search columns while adding want count', () => {
-        expect(command.columns).toEqual(['item_id', 'rank', 'title', 'price', 'condition', 'brand', 'location', 'badge', 'want', 'url']);
-    });
-    it('assigns contiguous ranks and passes item fields through', async () => {
-        const page = createPageMock({
-            items: [
-                { item_id: '111', title: 'A', price: '¥130000', condition: '几乎全新', brand: '小鹏', location: '深圳', badge: '信用极好', want: '3', url: 'u1' },
-                { item_id: '222', title: 'B', price: '¥185000', condition: '', brand: '', location: '深圳', badge: '', want: '0', url: 'u2' },
-            ],
-        });
-        const rows = await command.func(page, { query: '小鹏G9', city: '深圳', 'min-price': 100000, 'max-price': 200000 });
-        expect(rows.map((r) => r.rank)).toEqual([1, 2]);
-        expect(rows.map((r) => r.item_id)).toEqual(['111', '222']);
-        expect(rows[0]).toMatchObject({ rank: 1, price: '¥130000', condition: '几乎全新', brand: '小鹏', location: '深圳', badge: '信用极好' });
-    });
-    it('rejects an inverted price range before touching the page', async () => {
-        const page = createPageMock({ items: [] });
-        await expect(command.func(page, { query: '小鹏G9', 'min-price': 200000, 'max-price': 100000 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-    it('throws AuthRequiredError when the search needs a login', async () => {
-        const page = createPageMock({ error: 'auth-required' });
-        await expect(command.func(page, { query: '小鹏G9' })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('throws AuthRequiredError on an expired mtop session', async () => {
-        const page = createPageMock({ error: 'mtop-response-error', error_code: 'FAIL_SYS_SESSION_EXPIRED', error_message: 'x' });
-        await expect(command.func(page, { query: '小鹏G9' })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('throws CommandExecutionError on verification blocks', async () => {
-        const page = createPageMock({ error: 'blocked' });
-        await expect(command.func(page, { query: '小鹏G9' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('throws CommandExecutionError on malformed mtop payloads', async () => {
-        const page = createPageMock({ error: 'malformed-response', error_message: 'missing resultList' });
-        await expect(command.func(page, { query: '小鹏G9' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('throws CommandExecutionError when evaluate does not return an items array', async () => {
-        const page = createPageMock({});
-        await expect(command.func(page, { query: '小鹏G9' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('throws EmptyResultError when nothing matches the filters', async () => {
-        const page = createPageMock({ items: [] });
-        await expect(command.func(page, { query: '小鹏G9', city: '湛江', 'min-price': 5000000 })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-});