@jackwener/opencli 1.7.12 → 1.7.14

package/clis/wikidata/wikidata.test.js

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './entity.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('wikidata search adapter', () => {
+    const cmd = getRegistry().get('wikidata/search');
+
+    it('rejects bad args before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ query: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 999 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', language: '!!' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('throttled', { status: 429 })));
+        await expect(cmd.func({ query: 'einstein', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError on empty search list', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({ search: [] }), { status: 200 })));
+        await expect(cmd.func({ query: 'no-such-thing', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('round-trips Q-id from search row into wikidata.org URL', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
+            search: [{ id: 'Q937', label: 'Albert Einstein', description: 'physicist', match: { type: 'alias', text: 'Einstein' } }],
+        }), { status: 200 })));
+        const rows = await cmd.func({ query: 'einstein', limit: 5 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, qid: 'Q937', label: 'Albert Einstein', matchType: 'alias',
+            url: 'https://www.wikidata.org/wiki/Q937',
+        });
+    });
+});
+
+describe('wikidata entity adapter', () => {
+    const cmd = getRegistry().get('wikidata/entity');
+
+    it('rejects malformed entity ids before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(cmd.func({ id: '' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'not-a-qid' })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'Q' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('missing', { status: 404 })));
+        await expect(cmd.func({ id: 'Q9999999999' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('falls back to English label when requested language is missing', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
+            entities: {
+                Q937: {
+                    id: 'Q937', type: 'item', modified: '2026-01-01T00:00:00Z',
+                    labels: { en: { value: 'Albert Einstein', language: 'en' } },
+                    descriptions: { en: { value: 'physicist', language: 'en' } },
+                    aliases: { en: [{ value: 'A. Einstein', language: 'en' }] },
+                    claims: { P31: [], P21: [] },
+                    sitelinks: { enwiki: { title: 'Albert Einstein', site: 'enwiki' } },
+                },
+            },
+        }), { status: 200 })));
+        const rows = await cmd.func({ id: 'Q937', language: 'qq' });
+        expect(rows[0]).toMatchObject({
+            qid: 'Q937', label: 'Albert Einstein', description: 'physicist',
+            aliases: 'A. Einstein', claimPropertyCount: 2, sitelinkCount: 1,
+            enwikiTitle: 'Albert Einstein', url: 'https://www.wikidata.org/wiki/Q937',
+        });
+    });
+});

package/clis/wikipedia/page.js

@@ -0,0 +1,95 @@
+// wikipedia page — full article extract (plain text) with optional paragraph cap.
+//
+// Unlike `wikipedia summary` which returns the lead-section blurb truncated to
+// 300 chars, this adapter returns the *complete* article body (or the first N
+// paragraphs by explicit opt-in). No silent truncation: the caller decides.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    ArgumentError,
+    CommandExecutionError,
+    EmptyResultError,
+} from '@jackwener/opencli/errors';
+
+cli({
+    site: 'wikipedia',
+    name: 'page',
+    access: 'read',
+    description: 'Full plain-text extract of a Wikipedia article (optional paragraph cap).',
+    domain: 'wikipedia.org',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'title', positional: true, required: true, type: 'string', help: 'Article title (e.g. "Transformer (machine learning model)")' },
+        { name: 'lang', type: 'string', default: 'en', help: 'Language code (en, zh, ja, de, ...).' },
+        { name: 'paragraphs', type: 'int', default: 0, help: 'Cap to first N paragraphs (0 = full article).' },
+    ],
+    columns: ['title', 'description', 'pageId', 'paragraphs', 'extract', 'url'],
+    func: async (args) => {
+        const title = String(args.title ?? '').trim();
+        if (!title) {
+            throw new ArgumentError('wikipedia page title cannot be empty');
+        }
+        const lang = String(args.lang ?? 'en').trim().toLowerCase();
+        if (!/^[a-z]{2,3}(?:-[a-z0-9]+)?$/.test(lang)) {
+            throw new ArgumentError(`wikipedia lang must be a language code like en, zh, ja (got "${args.lang}")`);
+        }
+        const paragraphsCap = Number(args.paragraphs ?? 0);
+        if (!Number.isInteger(paragraphsCap) || paragraphsCap < 0) {
+            throw new ArgumentError('paragraphs must be a non-negative integer (0 = full article)');
+        }
+
+        const url = new URL(`https://${lang}.wikipedia.org/w/api.php`);
+        url.searchParams.set('action', 'query');
+        url.searchParams.set('format', 'json');
+        url.searchParams.set('formatversion', '2');
+        url.searchParams.set('prop', 'extracts|info|description');
+        url.searchParams.set('inprop', 'url');
+        url.searchParams.set('explaintext', '1');
+        url.searchParams.set('redirects', '1');
+        url.searchParams.set('titles', title);
+
+        let resp;
+        try {
+            resp = await fetch(url, {
+                headers: {
+                    'User-Agent': 'opencli/1.0 (+https://github.com/jackwener/opencli)',
+                    'Accept': 'application/json',
+                },
+            });
+        } catch (error) {
+            throw new CommandExecutionError(`wikipedia page request failed: ${error?.message || error}`);
+        }
+        if (!resp.ok) {
+            throw new CommandExecutionError(`wikipedia page failed: HTTP ${resp.status}`);
+        }
+        let data;
+        try {
+            data = await resp.json();
+        } catch (error) {
+            throw new CommandExecutionError(`wikipedia returned malformed JSON: ${error?.message || error}`);
+        }
+        if (data?.error) {
+            throw new CommandExecutionError(`wikipedia API error: ${data.error.info || data.error.code}`);
+        }
+        const pages = Array.isArray(data?.query?.pages) ? data.query.pages : [];
+        const page = pages[0];
+        if (!page || page.missing) {
+            throw new EmptyResultError('wikipedia page', `No article "${title}" on ${lang}.wikipedia.org. Try \`opencli wikipedia search\` first.`);
+        }
+        const fullExtract = String(page.extract ?? '');
+        if (!fullExtract.trim()) {
+            throw new EmptyResultError('wikipedia page', `Article "${page.title}" exists but has no plain-text extract (likely a disambiguation/redirect page).`);
+        }
+        const allParas = fullExtract.split(/\n{2,}/).map(s => s.trim()).filter(Boolean);
+        const paras = paragraphsCap > 0 ? allParas.slice(0, paragraphsCap) : allParas;
+
+        return [{
+            title: page.title,
+            description: page.description || '',
+            pageId: page.pageid ?? null,
+            paragraphs: paras.length,
+            extract: paras.join('\n\n'),
+            url: page.fullurl || `https://${lang}.wikipedia.org/wiki/${encodeURIComponent(page.title.replace(/ /g, '_'))}`,
+        }];
+    },
+});

package/clis/wttr/current.js

@@ -0,0 +1,63 @@
+// wttr current — current weather conditions for a city / lat,lon / airport code.
+//
+// Endpoint: GET /<location>?format=j1  → returns current_condition + nearest_area.
+// One row (current snapshot).
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { requireString, wttrFetch, pickWeatherDesc } from './utils.js';
+
+cli({
+    site: 'wttr',
+    name: 'current',
+    access: 'read',
+    description: 'Current weather conditions for a location (city, lat,lon, or airport code)',
+    domain: 'wttr.in',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'location',
+            positional: true,
+            required: true,
+            help: 'City name, "lat,lon", airport ICAO code, or "@domain"',
+        },
+    ],
+    columns: [
+        'location', 'region', 'country', 'latitude', 'longitude',
+        'observedAt', 'tempC', 'tempF', 'feelsLikeC', 'feelsLikeF',
+        'description', 'humidity', 'cloudCover', 'pressure',
+        'precipMm', 'visibilityKm', 'uvIndex',
+        'windKmph', 'windDirection', 'windDirectionDegree',
+    ],
+    func: async (args) => {
+        const location = requireString(args.location, 'location');
+        const body = await wttrFetch(location, 'wttr current');
+        const cur = Array.isArray(body?.current_condition) ? body.current_condition[0] : null;
+        if (!cur) {
+            throw new EmptyResultError('wttr current', `wttr.in returned no current conditions for "${location}".`);
+        }
+        const area = Array.isArray(body?.nearest_area) ? body.nearest_area[0] : null;
+        return [{
+            location: pickWeatherDesc(area?.areaName) || location,
+            region: pickWeatherDesc(area?.region),
+            country: pickWeatherDesc(area?.country),
+            latitude: area?.latitude ?? null,
+            longitude: area?.longitude ?? null,
+            observedAt: cur.localObsDateTime ?? null,
+            tempC: cur.temp_C != null ? Number(cur.temp_C) : null,
+            tempF: cur.temp_F != null ? Number(cur.temp_F) : null,
+            feelsLikeC: cur.FeelsLikeC != null ? Number(cur.FeelsLikeC) : null,
+            feelsLikeF: cur.FeelsLikeF != null ? Number(cur.FeelsLikeF) : null,
+            description: pickWeatherDesc(cur.weatherDesc),
+            humidity: cur.humidity != null ? Number(cur.humidity) : null,
+            cloudCover: cur.cloudcover != null ? Number(cur.cloudcover) : null,
+            pressure: cur.pressure != null ? Number(cur.pressure) : null,
+            precipMm: cur.precipMM != null ? Number(cur.precipMM) : null,
+            visibilityKm: cur.visibility != null ? Number(cur.visibility) : null,
+            uvIndex: cur.uvIndex != null ? Number(cur.uvIndex) : null,
+            windKmph: cur.windspeedKmph != null ? Number(cur.windspeedKmph) : null,
+            windDirection: cur.winddir16Point ?? null,
+            windDirectionDegree: cur.winddirDegree != null ? Number(cur.winddirDegree) : null,
+        }];
+    },
+});

package/clis/wttr/forecast.js

@@ -0,0 +1,71 @@
+// wttr forecast — multi-day forecast for a location.
+//
+// Endpoint: GET /<location>?format=j1  → returns weather[] (3 days max on free tier).
+// Each day is collapsed into a single row with min/max/avg + summary description.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { requireString, wttrFetch, pickWeatherDesc } from './utils.js';
+
+cli({
+    site: 'wttr',
+    name: 'forecast',
+    access: 'read',
+    description: 'Multi-day weather forecast (up to 3 days, wttr.in free tier max)',
+    domain: 'wttr.in',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        {
+            name: 'location',
+            positional: true,
+            required: true,
+            help: 'City name, "lat,lon", airport ICAO code, or "@domain"',
+        },
+        {
+            name: 'days',
+            type: 'int',
+            default: 3,
+            help: 'Max forecast days (1-3, wttr.in caps the response at 3 days)',
+        },
+    ],
+    columns: [
+        'rank', 'date', 'minTempC', 'maxTempC', 'avgTempC',
+        'minTempF', 'maxTempF', 'avgTempF',
+        'sunHour', 'totalSnowCm', 'uvIndex',
+        'description', 'sunrise', 'sunset',
+    ],
+    func: async (args) => {
+        const location = requireString(args.location, 'location');
+        const days = Number(args.days ?? 3);
+        if (!Number.isInteger(days) || days < 1 || days > 3) {
+            throw new ArgumentError('--days must be an integer between 1 and 3 (wttr.in caps the free-tier forecast at 3 days)');
+        }
+        const body = await wttrFetch(location, 'wttr forecast');
+        const list = Array.isArray(body?.weather) ? body.weather : [];
+        if (!list.length) {
+            throw new EmptyResultError('wttr forecast', `wttr.in returned no forecast for "${location}".`);
+        }
+        return list.slice(0, days).map((day, i) => {
+            // wttr.in's day-summary uses the noon hourly slot for "main" description.
+            // Index 4 = 12:00 in their 3-hour-step hourly array.
+            const noon = Array.isArray(day.hourly) && day.hourly[4] ? day.hourly[4] : day.hourly?.[0] ?? {};
+            const astro = Array.isArray(day.astronomy) ? day.astronomy[0] : null;
+            return {
+                rank: i + 1,
+                date: day.date ?? null,
+                minTempC: day.mintempC != null ? Number(day.mintempC) : null,
+                maxTempC: day.maxtempC != null ? Number(day.maxtempC) : null,
+                avgTempC: day.avgtempC != null ? Number(day.avgtempC) : null,
+                minTempF: day.mintempF != null ? Number(day.mintempF) : null,
+                maxTempF: day.maxtempF != null ? Number(day.maxtempF) : null,
+                avgTempF: day.avgtempF != null ? Number(day.avgtempF) : null,
+                sunHour: day.sunHour != null ? Number(day.sunHour) : null,
+                totalSnowCm: day.totalSnow_cm != null ? Number(day.totalSnow_cm) : null,
+                uvIndex: day.uvIndex != null ? Number(day.uvIndex) : null,
+                description: pickWeatherDesc(noon?.weatherDesc),
+                sunrise: astro?.sunrise ?? null,
+                sunset: astro?.sunset ?? null,
+            };
+        });
+    },
+});

package/clis/wttr/utils.js

@@ -0,0 +1,50 @@
+// wttr.in shared helpers — global weather (no auth, terminal-friendly JSON via ?format=j1).
+//
+// Coverage: worldwide. Unlike NWS (US-only), wttr.in geocodes any city/airport
+// code/lat,lon string and serves a 3-day forecast + current conditions in one
+// payload.
+import { ArgumentError, EmptyResultError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+export const WTTR_BASE = 'https://wttr.in';
+const UA = 'opencli-wttr/1.0';
+
+export function requireString(value, name) {
+    if (typeof value !== 'string' || !value.trim()) {
+        throw new ArgumentError(`--${name} is required`);
+    }
+    return value.trim();
+}
+
+export async function wttrFetch(location, label) {
+    // wttr.in path-encodes the location. Spaces → %20 is fine; commas survive.
+    const url = `${WTTR_BASE}/${encodeURIComponent(location)}?format=j1`;
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'User-Agent': UA, accept: 'application/json' } });
+    } catch (err) {
+        throw new CommandExecutionError(`${label} request failed: ${err.message}`);
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `${label} could not find location "${location}".`);
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}.`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    } catch (err) {
+        // wttr.in falls back to plain-text "Unknown location" for some bad inputs;
+        // promote that to EmptyResult instead of pretending we got JSON.
+        throw new EmptyResultError(label, `${label} returned non-JSON body (likely unknown location).`);
+    }
+    return body;
+}
+
+// wttr.in's "weatherDesc" / "lang_en" fields are arrays of `{ value: '...' }` objects.
+// Single-element 99% of the time but the schema is a list.
+export function pickWeatherDesc(arr) {
+    if (!Array.isArray(arr) || !arr.length) return '';
+    const first = arr[0];
+    return typeof first?.value === 'string' ? first.value.trim() : '';
+}

package/clis/wttr/wttr.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import './current.js';
+import './forecast.js';
+
+const origFetch = global.fetch;
+afterEach(() => { global.fetch = origFetch; });
+
+const sampleBody = {
+    current_condition: [{
+        temp_C: '18', temp_F: '65', FeelsLikeC: '17', FeelsLikeF: '63',
+        humidity: '70', cloudcover: '50', pressure: '1015', precipMM: '0.2',
+        visibility: '10', uvIndex: '4', windspeedKmph: '12', winddir16Point: 'NE', winddirDegree: '45',
+        weatherDesc: [{ value: 'Partly cloudy' }],
+        localObsDateTime: '2026-05-06 10:00 AM',
+    }],
+    nearest_area: [{
+        areaName: [{ value: 'Tokyo' }],
+        country: [{ value: 'Japan' }],
+        region: [{ value: 'Tokyo' }],
+        latitude: '35.685', longitude: '139.752',
+    }],
+    weather: [
+        {
+            date: '2026-05-06', mintempC: '15', maxtempC: '22', avgtempC: '18',
+            mintempF: '59', maxtempF: '72', avgtempF: '65',
+            sunHour: '12.0', totalSnow_cm: '0.0', uvIndex: '4',
+            astronomy: [{ sunrise: '04:50 AM', sunset: '06:35 PM' }],
+            hourly: [
+                {}, {}, {}, {},
+                { weatherDesc: [{ value: 'Sunny' }] },
+                {},
+            ],
+        },
+    ],
+};
+
+describe('wttr current', () => {
+    const cmd = getRegistry().get('wttr/current');
+
+    it('rejects empty location', async () => {
+        await expect(cmd.func({ location: '' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('promotes 404 to EmptyResultError', async () => {
+        global.fetch = vi.fn(() => Promise.resolve(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ location: 'Atlantis' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('promotes non-JSON body to EmptyResultError', async () => {
+        global.fetch = vi.fn(() => Promise.resolve(new Response('Unknown location', { status: 200 })));
+        await expect(cmd.func({ location: 'asdf' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('shapes current row + numeric coercion', async () => {
+        global.fetch = vi.fn(() => Promise.resolve(new Response(JSON.stringify(sampleBody), { status: 200 })));
+        const rows = await cmd.func({ location: 'Tokyo' });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].location).toBe('Tokyo');
+        expect(rows[0].country).toBe('Japan');
+        expect(rows[0].tempC).toBe(18);
+        expect(rows[0].description).toBe('Partly cloudy');
+        expect(rows[0].windDirection).toBe('NE');
+    });
+});
+
+describe('wttr forecast', () => {
+    const cmd = getRegistry().get('wttr/forecast');
+
+    it('rejects --days out of range', async () => {
+        await expect(cmd.func({ location: 'Tokyo', days: 5 })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('shapes forecast rows + picks noon description', async () => {
+        global.fetch = vi.fn(() => Promise.resolve(new Response(JSON.stringify(sampleBody), { status: 200 })));
+        const rows = await cmd.func({ location: 'Tokyo' });
+        expect(rows).toHaveLength(1);
+        expect(rows[0]).toMatchObject({
+            rank: 1, date: '2026-05-06', minTempC: 15, maxTempC: 22, avgTempC: 18,
+            description: 'Sunny', sunrise: '04:50 AM', sunset: '06:35 PM',
+        });
+    });
+});

package/clis/xianyu/chat.js

@@ -12,8 +12,9 @@ function buildExtractChatStateEvaluate() {
       const requiresAuth = /请先登录|登录后/.test(bodyText);
 
       const textarea = document.querySelector('textarea');
+      const normalizeBtn = (s) => (s || '').replace(/\\s+/g, '').trim();
       const sendButton = Array.from(document.querySelectorAll('button'))
-        .find((btn) => clean(btn.textContent || '') === '发送');
+        .find((btn) => normalizeBtn(btn.textContent || '') === '发送');
       const topbar = document.querySelector('[class*="message-topbar"]');
       const itemCard = Array.from(document.querySelectorAll('a[href*="/item?id="]'))
         .find((el) => el.closest('main'));
@@ -51,7 +52,7 @@ function buildExtractChatStateEvaluate() {
 }
 function buildSendMessageEvaluate(text) {
     return `
-    (() => {
+    (async () => {
       const clean = (value) => (value || '').replace(/\\s+/g, ' ').trim();
       const textarea = document.querySelector('textarea');
       if (!textarea || textarea.disabled) {
@@ -63,13 +64,22 @@ function buildSendMessageEvaluate(text) {
         return { ok: false, reason: 'textarea-setter-not-found' };
       }
 
+      // Click textarea first to activate chat and trigger send button to appear
+      textarea.click();
       textarea.focus();
       setter.call(textarea, ${JSON.stringify(text)});
       textarea.dispatchEvent(new Event('input', { bubbles: true }));
       textarea.dispatchEvent(new Event('change', { bubbles: true }));
 
-      const sendButton = Array.from(document.querySelectorAll('button'))
-        .find((btn) => clean(btn.textContent || '') === '发送');
+      // Poll up to 3s for send button (may appear after textarea interaction)
+      const normalizeBtn = (s) => (s || '').replace(/\\s+/g, '').trim();
+      let sendButton = null;
+      for (let i = 0; i < 30; i++) {
+        sendButton = Array.from(document.querySelectorAll('button'))
+          .find((btn) => normalizeBtn(btn.textContent || '') === '发送');
+        if (sendButton) break;
+        await new Promise(r => setTimeout(r, 100));
+      }
       if (!sendButton) {
         return { ok: false, reason: 'send-button-not-found' };
       }
@@ -144,4 +154,6 @@ cli({
 export const __test__ = {
     normalizeNumericId,
     buildChatUrl,
+    buildExtractChatStateEvaluate,
+    buildSendMessageEvaluate,
 };

package/clis/xianyu/chat.test.js

@@ -1,5 +1,13 @@
+import { JSDOM } from 'jsdom';
 import { describe, expect, it } from 'vitest';
 import { __test__ } from './chat.js';
+
+async function runBrowserScript(html, script, { url = 'https://www.goofish.com/im', beforeEval } = {}) {
+    const dom = new JSDOM(html, { url, runScripts: 'outside-only' });
+    beforeEval?.(dom.window);
+    return dom.window.eval(script);
+}
+
 describe('xianyu chat helpers', () => {
     it('builds goofish im urls from ids', () => {
         expect(__test__.buildChatUrl('1038951278192', '3650092411')).toBe('https://www.goofish.com/im?itemId=1038951278192&peerUserId=3650092411');
@@ -12,4 +20,60 @@ describe('xianyu chat helpers', () => {
         expect(() => __test__.normalizeNumericId('abc', 'item_id', '1038951278192')).toThrow();
         expect(() => __test__.normalizeNumericId('3650092411x', 'user_id', '3650092411')).toThrow();
     });
+
+    it('detects send buttons with whitespace-split text in the in-browser state extractor', async () => {
+        const state = await runBrowserScript(`
+            <main>
+              <textarea></textarea>
+              <button>发 送</button>
+              <div id="message-list-scrollable"><div class="bubble">你好</div></div>
+            </main>
+        `, __test__.buildExtractChatStateEvaluate());
+
+        expect(state.can_input).toBe(true);
+        expect(state.can_send).toBe(true);
+        expect(state.visible_messages).toEqual(['你好']);
+    });
+
+    it('activates the textarea and waits for a whitespace-split send button before clicking it', async () => {
+        let inputValue = '';
+        let sendClicked = false;
+        const result = await runBrowserScript(`
+            <main>
+              <textarea></textarea>
+            </main>
+        `, __test__.buildSendMessageEvaluate('还在吗？'), {
+            beforeEval(window) {
+                const textarea = window.document.querySelector('textarea');
+                textarea.addEventListener('input', () => {
+                    inputValue = textarea.value;
+                });
+                textarea.addEventListener('click', () => {
+                    const button = window.document.createElement('button');
+                    button.textContent = '发 送';
+                    button.addEventListener('click', () => {
+                        sendClicked = true;
+                    });
+                    window.document.body.append(button);
+                });
+            },
+        });
+
+        expect(result).toEqual({ ok: true });
+        expect(inputValue).toBe('还在吗？');
+        expect(sendClicked).toBe(true);
+    });
+
+    it('returns a typed failure reason when activation still does not reveal the send button', async () => {
+        const result = await runBrowserScript('<textarea></textarea>', __test__.buildSendMessageEvaluate('ping'), {
+            beforeEval(window) {
+                window.setTimeout = (fn) => {
+                    fn();
+                    return 0;
+                };
+            },
+        });
+
+        expect(result).toEqual({ ok: false, reason: 'send-button-not-found' });
+    });
 });