@jackwener/opencli 1.7.12 → 1.7.13

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