@jackwener/opencli 1.7.17 → 1.7.19

package/clis/ctrip/hotel-search.js

@@ -0,0 +1,132 @@
+/**
+ * 携程酒店 list — search hotels by city + date range.
+ *
+ * Reads `window.__NEXT_DATA__.props.pageProps.initListData.hotelList` directly
+ * from the SSR-rendered hotel listing page. Ctrip serves first 13 hotels
+ * (10 organic + ~3 promoted) inline; `&pageSize=N` URL params are ignored
+ * server-side so we cap default limit accordingly (see
+ * `~/.opencli/sites/ctrip/notes.md`).
+ *
+ * Reuses the existing `mapHotelRow` + `pickHotelMapCoords` helpers from utils.js
+ * so the column shape stays consistent if future variants (hotel-detail) also
+ * project from the same `hotelInfo` shape.
+ *
+ * Anti-bot: not detected on first-page navigation (PR #1481 recon 2026-05-12).
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { mapHotelRow, parseCityId, parseIsoDate } from './utils.js';
+
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 30;
+const DEFAULT_LIMIT = 10;
+
+function parseHotelLimit(raw) {
+    if (raw === undefined || raw === null || raw === '') return DEFAULT_LIMIT;
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed)) {
+        throw new ArgumentError(`--limit must be an integer between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${JSON.stringify(raw)}`);
+    }
+    if (parsed < MIN_LIMIT || parsed > MAX_LIMIT) {
+        throw new ArgumentError(`--limit must be between ${MIN_LIMIT} and ${MAX_LIMIT}, got ${parsed}`);
+    }
+    return parsed;
+}
+
+/**
+ * Wait for SSR state to be populated, or detect a login/captcha gate.
+ *
+ * Ctrip occasionally serves a captcha redirect (`/captcha`) when traffic
+ * looks bot-like; we catch that as AuthRequired so the agent can pop a
+ * human session instead of looping on an empty extract.
+ */
+const WAIT_FOR_SSR_JS = `
+  new Promise((resolve) => {
+    const detect = () => {
+      if (location.pathname.includes('captcha') || /验证码|verify the human/i.test(document.body?.innerText || '')) return 'captcha';
+      const hotels = window.__NEXT_DATA__?.props?.pageProps?.initListData?.hotelList;
+      if (Array.isArray(hotels)) return 'content';
+      return null;
+    };
+    const found = detect();
+    if (found) return resolve(found);
+    const observer = new MutationObserver(() => {
+      const result = detect();
+      if (result) { observer.disconnect(); resolve(result); }
+    });
+    observer.observe(document.documentElement, { childList: true, subtree: true });
+    setTimeout(() => { observer.disconnect(); resolve('timeout'); }, 5000);
+  })
+`;
+
+const EXTRACT_HOTELS_JS = `
+  (() => {
+    const list = window.__NEXT_DATA__?.props?.pageProps?.initListData?.hotelList;
+    if (!Array.isArray(list)) return null;
+    return list;
+  })()
+`;
+
+function assertCheckinBeforeCheckout(checkin, checkout) {
+    if (Date.parse(checkin + 'T00:00:00Z') >= Date.parse(checkout + 'T00:00:00Z')) {
+        throw new ArgumentError(`--checkin must be earlier than --checkout (got ${checkin} >= ${checkout})`);
+    }
+}
+
+cli({
+    site: 'ctrip',
+    name: 'hotel-search',
+    access: 'read',
+    description: '搜索携程酒店列表（按城市 + 入住/离店日期）',
+    domain: 'hotels.ctrip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'city', required: true, positional: true, help: 'Numeric Ctrip city ID (use `ctrip search` or `ctrip hotel-suggest` to discover)' },
+        { name: 'checkin', required: true, help: 'Check-in date (YYYY-MM-DD)' },
+        { name: 'checkout', required: true, help: 'Check-out date (YYYY-MM-DD)' },
+        { name: 'limit', type: 'int', default: DEFAULT_LIMIT, help: `Number of hotels (${MIN_LIMIT}-${MAX_LIMIT}); SSR first page returns ~13 entries` },
+    ],
+    columns: [
+        'rank', 'hotelId', 'name', 'enName',
+        'star', 'score', 'scoreLabel', 'reviewCount',
+        'cityName', 'district', 'address',
+        'lat', 'lon',
+        'price', 'currency', 'url',
+    ],
+    func: async (page, kwargs) => {
+        const cityId = parseCityId(kwargs.city);
+        const checkin = parseIsoDate('checkin', kwargs.checkin);
+        const checkout = parseIsoDate('checkout', kwargs.checkout);
+        assertCheckinBeforeCheckout(checkin, checkout);
+        const limit = parseHotelLimit(kwargs.limit);
+
+        const url = `https://hotels.ctrip.com/hotels/list?city=${cityId}&checkin=${checkin}&checkout=${checkout}`;
+        await page.goto(url);
+        const waitResult = await page.evaluate(WAIT_FOR_SSR_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('hotels.ctrip.com', 'Ctrip is asking for a captcha; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Ctrip hotel-search page did not expose SSR hotel list (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(EXTRACT_HOTELS_JS);
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Ctrip hotel-search returned malformed SSR hotel list');
+        }
+        if (raw.length === 0) {
+            throw new EmptyResultError('ctrip hotel-search', `No hotels for city=${cityId} on ${checkin} → ${checkout}`);
+        }
+        const rows = raw
+            .map((entry, i) => mapHotelRow(entry, i))
+            .filter((row) => row.hotelId && row.name)
+            .slice(0, limit);
+        if (rows.length === 0) {
+            throw new CommandExecutionError('Ctrip hotel-search SSR rows were missing required hotelId/name anchors');
+        }
+        return rows;
+    },
+});
+
+export const __test__ = { parseHotelLimit, assertCheckinBeforeCheckout, WAIT_FOR_SSR_JS, EXTRACT_HOTELS_JS };

package/clis/ctrip/utils.js

@@ -172,4 +172,302 @@ export function mapSuggestRow(item, index) {
     };
 }
 
+/* --------- Helpers shared by hotel-search / flight (browser-context) ---------- */
+
+const ISO_DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+
+/**
+ * Validate YYYY-MM-DD and return the canonical string. Rejects out-of-range
+ * month/day, malformed input, and silent NaN. Does NOT coerce or shift timezones.
+ */
+export function parseIsoDate(name, raw) {
+    if (raw === undefined || raw === null || raw === '') {
+        throw new ArgumentError(`--${name} is required (YYYY-MM-DD)`);
+    }
+    const value = String(raw).trim();
+    const m = ISO_DATE_RE.exec(value);
+    if (!m) {
+        throw new ArgumentError(`--${name} must be YYYY-MM-DD, got ${JSON.stringify(raw)}`);
+    }
+    const year = Number(m[1]);
+    const month = Number(m[2]);
+    const day = Number(m[3]);
+    if (month < 1 || month > 12 || day < 1 || day > 31) {
+        throw new ArgumentError(`--${name} has invalid month/day: ${value}`);
+    }
+    // Cross-check via UTC date math so 2026-02-30 doesn't pass.
+    const parsed = new Date(Date.UTC(year, month - 1, day));
+    if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) {
+        throw new ArgumentError(`--${name} is not a real calendar date: ${value}`);
+    }
+    return value;
+}
+
+/**
+ * Validate a 3-letter IATA airport / metro code, return uppercase.
+ * Ctrip URL accepts both single-airport (PEK / PVG) and metro-group (BJS / SHA) codes.
+ */
+export function parseIataCode(name, raw) {
+    if (raw === undefined || raw === null || raw === '') {
+        throw new ArgumentError(`--${name} is required (3-letter IATA code, e.g. PEK, SHA)`);
+    }
+    const value = String(raw).trim().toUpperCase();
+    if (!/^[A-Z]{3}$/.test(value)) {
+        throw new ArgumentError(`--${name} must be a 3-letter IATA code, got ${JSON.stringify(raw)}`);
+    }
+    return value;
+}
+
+/**
+ * Validate a numeric Ctrip city ID (returned by `ctrip search` / `ctrip hotel-suggest`).
+ */
+export function parseCityId(raw) {
+    if (raw === undefined || raw === null || raw === '') {
+        throw new ArgumentError('--city is required (numeric city ID from `ctrip search` or `ctrip hotel-suggest`)');
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) {
+        throw new ArgumentError(`--city must be a positive integer city ID, got ${JSON.stringify(raw)}`);
+    }
+    return parsed;
+}
+
+/**
+ * Pick the best lat/lon from a Ctrip hotel `positionInfo.mapCoordinate` array.
+ *
+ * Each entry has a `coordinateType` (1=WGS84, 2=GCJ02, 3=BD09 / Baidu). We prefer
+ * WGS84 when present (most portable), then fall through. All coordinates are
+ * strings in the API, so we Number() and reject NaN.
+ */
+export function pickHotelMapCoords(mapCoordinate) {
+    if (!Array.isArray(mapCoordinate) || mapCoordinate.length === 0) {
+        return { lat: null, lon: null };
+    }
+    // Order: WGS84 (1) → GCJ02 (2) → BD09 (3) → whatever exists
+    const ranking = (entry) => {
+        const t = Number(entry?.coordinateType);
+        if (t === 1) return 0;
+        if (t === 2) return 1;
+        if (t === 3) return 2;
+        return 3;
+    };
+    const sorted = [...mapCoordinate].sort((a, b) => ranking(a) - ranking(b));
+    for (const entry of sorted) {
+        const lat = Number(entry?.latitude);
+        const lon = Number(entry?.longitude);
+        if (Number.isFinite(lat) && Number.isFinite(lon) && (lat !== 0 || lon !== 0)) {
+            return { lat, lon };
+        }
+    }
+    return { lat: null, lon: null };
+}
+
+/**
+ * Project a single Ctrip hotel row from `__NEXT_DATA__.props.pageProps.initListData.hotelList[*]`
+ * into stable adapter column shape.
+ *
+ * No silent fallbacks — every field is `string|number|null`, never `''` masquerading
+ * as "no data" (see typed-errors.md §"scalar sentinels are anti-pattern").
+ */
+export function mapHotelRow(entry, index) {
+    const hotelInfo = entry?.hotelInfo ?? {};
+    const rooms = Array.isArray(entry?.roomInfo) ? entry.roomInfo : [];
+    const summary = hotelInfo.summary ?? {};
+    const nameInfo = hotelInfo.nameInfo ?? {};
+    const hotelStar = hotelInfo.hotelStar ?? {};
+    const commentInfo = hotelInfo.commentInfo ?? {};
+    const positionInfo = hotelInfo.positionInfo ?? {};
+    const firstRoom = rooms[0] ?? {};
+    const priceInfo = firstRoom.priceInfo ?? {};
+
+    const hotelId = summary.hotelId ? String(summary.hotelId) : null;
+    const { lat, lon } = pickHotelMapCoords(positionInfo.mapCoordinate);
+
+    // commenterNumber arrives as "13,966条点评" — strip non-digits to int, else null.
+    let reviewCount = null;
+    if (commentInfo.commenterNumber) {
+        const digits = String(commentInfo.commenterNumber).replace(/[^\d]/g, '');
+        if (digits) reviewCount = Number(digits);
+    }
+    const score = commentInfo.commentScore ? Number(commentInfo.commentScore) : null;
+
+    const star = Number.isFinite(hotelStar.star) && hotelStar.star > 0 ? hotelStar.star : null;
+    const price = Number.isFinite(priceInfo.price) && priceInfo.price > 0 ? priceInfo.price : null;
+
+    return {
+        rank: index + 1,
+        hotelId,
+        name: nameInfo.name ? String(nameInfo.name).trim() : null,
+        enName: nameInfo.enName ? String(nameInfo.enName).trim() : null,
+        star,
+        score: Number.isFinite(score) && score > 0 ? score : null,
+        scoreLabel: commentInfo.commentDescription ? String(commentInfo.commentDescription).trim() : null,
+        reviewCount,
+        cityName: positionInfo.cityName ? String(positionInfo.cityName).trim() : null,
+        district: positionInfo.positionDesc ? String(positionInfo.positionDesc).trim() : null,
+        address: positionInfo.address ? String(positionInfo.address).trim() : null,
+        lat,
+        lon,
+        price,
+        currency: priceInfo.currency ? String(priceInfo.currency).trim() : null,
+        url: hotelId ? `https://hotels.ctrip.com/hotels/detail/?hotelid=${hotelId}` : null,
+    };
+}
+
+/**
+ * Build the browser-context IIFE that extracts flight rows from `.flight-list`.
+ *
+ * Flights are rendered as `.flight-list > span > div` cards. Each card's innerText
+ * has a stable ordering (verified 2026-05-12 on bjs→sha route):
+ *
+ *   [airline, flightNo, aircraft, lowPriceTag?, depTime, depAirport,
+ *    arrTime, arrAirport, terminal?, savings?, promo?, currency, price,
+ *    priceSuffix, cabin, cta]
+ *
+ * `lowPriceTag` (e.g. "当日低价") + `terminal` (e.g. "T2") + `savings` + `promo`
+ * are optional — we use position-of-first-time-match to anchor and parse around it.
+ *
+ * The host is baked in so `normalizeUrl` for booking links resolves on the calling site.
+ */
+export function buildFlightExtractJs() {
+    return `
+      (() => {
+        const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+        const isTime = (s) => /^([01]?\\d|2[0-3]):[0-5]\\d$/.test(s);
+        const isCurrency = (s) => /^[¥$€£]$/.test(s);
+        const isPriceDigits = (s) => /^\\d+([.,]\\d+)?$/.test(s);
+        const isFlightNo = (s) => /^[A-Z0-9]{2}\\d{3,4}[A-Z]?$/.test(s);
+
+        const rows = [];
+        document.querySelectorAll('.flight-list > span > div').forEach((card) => {
+          // Collect ordered text chunks (text nodes only, skip whitespace-only).
+          const chunks = [];
+          const walk = (node) => {
+            for (const c of node.childNodes) {
+              if (c.nodeType === 3) {
+                const t = cleanText(c.textContent);
+                if (t) chunks.push(t);
+              } else if (c.nodeType === 1) {
+                walk(c);
+              }
+            }
+          };
+          walk(card);
+          if (chunks.length < 8) return;
+
+          // Anchor on first HH:MM — that's depTime; depAirport is immediately after.
+          const firstTimeIdx = chunks.findIndex(isTime);
+          if (firstTimeIdx < 1) return;
+          const airline = chunks[0];
+          const flightNo = chunks[1] || null;
+          if (!airline || !isFlightNo(flightNo)) return;
+          const aircraft = chunks[2] && !isTime(chunks[2]) ? chunks[2] : null;
+
+          const depTime = chunks[firstTimeIdx];
+          const depAirport = chunks[firstTimeIdx + 1] || null;
+          // Second HH:MM after depTime is arrTime
+          const arrTimeIdx = chunks.findIndex((c, i) => i > firstTimeIdx && isTime(c));
+          if (arrTimeIdx < 0) return;
+          const arrTime = chunks[arrTimeIdx];
+          const arrAirport = chunks[arrTimeIdx + 1] || null;
+          if (!depAirport || !arrAirport) return;
+          // Optional terminal chunk right after arrAirport (matches /^T\\d$/ or single letter)
+          let terminal = null;
+          if (arrTimeIdx + 2 < chunks.length && /^T\\d$/.test(chunks[arrTimeIdx + 2])) {
+            terminal = chunks[arrTimeIdx + 2];
+          }
+
+          // Price: scan for currency symbol then a digit-only chunk
+          let price = null;
+          let currency = null;
+          for (let i = 0; i < chunks.length - 1; i++) {
+            if (isCurrency(chunks[i]) && isPriceDigits(chunks[i + 1])) {
+              currency = chunks[i];
+              price = Number(chunks[i + 1].replace(',', ''));
+              break;
+            }
+          }
+          // Cabin: scan from end for first non-CTA Chinese chunk ending in "舱"
+          let cabin = null;
+          for (let i = chunks.length - 1; i >= 0; i--) {
+            if (/舱$/.test(chunks[i])) { cabin = chunks[i]; break; }
+          }
+
+          rows.push({
+            airline,
+            flightNo,
+            aircraft,
+            departureTime: depTime,
+            departureAirport: depAirport,
+            arrivalTime: arrTime,
+            arrivalAirport: arrAirport,
+            terminal,
+            price,
+            currency,
+            cabin,
+          });
+        });
+        return rows;
+      })()
+    `;
+}
+
+/**
+ * Build a scroll-until-enough IIFE for flights/hotels DOM-card pagination.
+ *
+ * Mirrors `clis/xiaohongshu/search.js#buildScrollUntilJs` (PR #1487) — counts a
+ * caller-supplied row selector, scrolls until count >= target / DOM plateau /
+ * maxScrolls. Returns final row count so the caller can decide whether to
+ * surface an EmptyResultError. (xiaohongshu's helper hardcodes
+ * `section.note-item`; this generic version takes a selector.)
+ */
+export function buildScrollUntilJs(rowSelector, targetCount, maxScrolls = 8) {
+    if (!Number.isInteger(targetCount) || targetCount < 1 || targetCount > 100) {
+        throw new ArgumentError(`targetCount must be an integer between 1 and 100, got ${JSON.stringify(targetCount)}`);
+    }
+    if (!Number.isInteger(maxScrolls) || maxScrolls < 1 || maxScrolls > 30) {
+        throw new ArgumentError(`maxScrolls must be an integer between 1 and 30, got ${JSON.stringify(maxScrolls)}`);
+    }
+    return `
+      (async () => {
+        const sel = ${JSON.stringify(rowSelector)};
+        const isVisible = (el) => {
+          const style = window.getComputedStyle(el);
+          if (style.display === 'none' || style.visibility === 'hidden' || Number(style.opacity) === 0) return false;
+          const rect = el.getBoundingClientRect();
+          return rect.width > 0 && rect.height > 0;
+        };
+        const countItems = () => Array.from(document.querySelectorAll(sel)).filter(isVisible).length;
+        let lastCount = countItems();
+        let plateauRounds = 0;
+        for (let i = 0; i < ${maxScrolls}; i++) {
+          if (countItems() >= ${targetCount}) break;
+          const lastHeight = document.body.scrollHeight;
+          window.scrollTo(0, lastHeight);
+          await new Promise((resolve) => {
+            let to;
+            const ob = new MutationObserver(() => {
+              if (document.body.scrollHeight > lastHeight) {
+                clearTimeout(to);
+                ob.disconnect();
+                setTimeout(resolve, 200);
+              }
+            });
+            ob.observe(document.body, { childList: true, subtree: true });
+            to = setTimeout(() => { ob.disconnect(); resolve(null); }, 2500);
+          });
+          const newCount = countItems();
+          if (newCount === lastCount) {
+            plateauRounds++;
+            if (plateauRounds >= 2) break;
+          } else {
+            plateauRounds = 0;
+            lastCount = newCount;
+          }
+        }
+        return countItems();
+      })()
+    `;
+}
+
 export const __test__ = { ENDPOINT, MIN_LIMIT, MAX_LIMIT };

package/clis/doubao/utils.js

@@ -163,6 +163,19 @@ function getTurnsScript() {
         ) {
           return 'Assistant';
         }
+        // 2026-05 Doubao DOM refactor: no more receive-message / bg-g-receive-msg-bubble
+        // markers on assistant turns. Wrappers are now [class*="inner-item-"] /
+        // [class*="top-item-"] and the only reliable assistant signal is the
+        // .flow-markdown-body content container WITHOUT any send-bubble marker.
+        if (
+          (root.matches('[class*="inner-item-"], [class*="top-item-"]')
+            || root.closest('[class*="inner-item-"], [class*="top-item-"]'))
+          && (root.matches('.flow-markdown-body') || root.querySelector('.flow-markdown-body'))
+          && !root.matches('[class*="bg-g-send-msg-bubble"]')
+          && !root.querySelector('[class*="bg-g-send-msg-bubble"]')
+        ) {
+          return 'Assistant';
+        }
         return '';
       };
 
@@ -223,6 +236,10 @@ function getTurnsScript() {
       if (!messageList) return [];
 
       const itemSelectors = [
+        // 2026-05 Doubao DOM refactor wrappers (prepended; outer ones win via
+        // ancestor-keep dedup below).
+        '[class*="inner-item-"]',
+        '[class*="top-item-"]',
         '[class*="item-kDun2N"]',
         '[data-testid="union_message"]',
         '[data-testid="message-block-container"]',

package/clis/doubao/utils.test.js

@@ -1,3 +1,4 @@
+import { JSDOM } from 'jsdom';
 import { describe, expect, it, vi } from 'vitest';
 import { CommandExecutionError } from '@jackwener/opencli/errors';
 import {
@@ -145,6 +146,28 @@ describe('doubao send strategy', () => {
     });
 });
 describe('doubao receive strategy', () => {
+    function runTurnsScript(html) {
+        const dom = new JSDOM(html, { url: 'https://www.doubao.com/chat', runScripts: 'outside-only' });
+        Object.defineProperty(dom.window.HTMLElement.prototype, 'innerText', {
+            configurable: true,
+            get() {
+                return this.textContent || '';
+            },
+        });
+        dom.window.HTMLElement.prototype.getBoundingClientRect = () => ({
+            width: 100,
+            height: 24,
+            top: 0,
+            left: 0,
+            right: 100,
+            bottom: 24,
+            x: 0,
+            y: 0,
+            toJSON: () => ({}),
+        });
+        return dom.window.eval(__test__.getTurnsScript());
+    }
+
     it('keeps both the new skin selectors and the older structural fallbacks in the turns script', () => {
         const turnsScript = __test__.getTurnsScript();
         expect(turnsScript).toContain('[class*="message-list-S2Fv2S"]');
@@ -157,6 +180,44 @@ describe('doubao receive strategy', () => {
         expect(turnsScript).toContain('[data-testid="message-block-container"]');
     });
 
+    it('includes the 2026-05 doubao DOM-refactor inner-item / top-item wrappers and the flow-markdown-body assistant fallback', () => {
+        const turnsScript = __test__.getTurnsScript();
+        // New wrappers added to itemSelectors so message roots resolve under the
+        // refactored DOM where the legacy item-kDun2N / union_message / message-block-container
+        // / data-message-id selectors no longer match.
+        expect(turnsScript).toContain('[class*="inner-item-"]');
+        expect(turnsScript).toContain('[class*="top-item-"]');
+        // Assistant fallback: post-refactor doubao no longer emits receive-message /
+        // bg-g-receive-msg-bubble markup. Only signal is .flow-markdown-body content
+        // container without send-bubble.
+        expect(turnsScript).toContain('.flow-markdown-body');
+    });
+
+    it('extracts clean assistant turns from the 2026-05 wrapper DOM without using whole-page chrome', () => {
+        const turns = runTurnsScript(`
+          <main>
+            <aside>历史对话</aside>
+            <section class="message-list-S2Fv2S">
+              <div class="top-item-user">
+                <div class="inner-item-user">
+                  <div class="bg-g-send-msg-bubble">测试一下，只回复OK</div>
+                </div>
+              </div>
+              <div class="top-item-assistant">
+                <div class="inner-item-assistant">
+                  <div class="flow-markdown-body"><p>OK</p></div>
+                </div>
+              </div>
+            </section>
+          </main>
+        `);
+
+        expect(turns).toEqual([
+            { Role: 'User', Text: '测试一下，只回复OK' },
+            { Role: 'Assistant', Text: 'OK' },
+        ]);
+    });
+
     it('extends transcript-noise cleanup for the current zh-CN chrome copy', () => {
         const transcriptScript = __test__.getTranscriptLinesScript();
         expect(transcriptScript).toContain('请仔细甄别');

package/clis/google/search.js

@@ -29,13 +29,22 @@ cli({
         const lang = encodeURIComponent(args.lang);
         const url = `https://www.google.com/search?q=${keyword}&hl=${lang}&num=${limit}`;
         await page.goto(url);
-        await page.wait(2);
-        const results = await page.evaluate(`
+        // Wait until at least one SERP title link is present. On Chrome 148 /
+        // Linux Wayland, DOM stability can be reached before #rso anchors are
+        // populated, making browser execution look visually correct while the
+        // adapter extracts an empty array.
+        try {
+            await page.wait({ selector: '#rso a h3', timeout: 5 });
+        }
+        catch {
+            await page.wait(2);
+        }
+        const wrapper = await page.evaluate(`
       (function() {
         var results = [];
         var seenUrls = {};
         var rso = document.querySelector('#rso');
-        if (!rso) return results;
+        if (!rso) return {items: results};
 
         // -- Featured snippet (scoped to #rso to avoid matching unrelated elements) --
         var featuredEl = rso.querySelector('.xpdopen .hgKElc')
@@ -63,7 +72,7 @@ cli({
 
           var href = link.href || '';
           // Skip non-http, Google internal links, and duplicates
-          if (!href.match(/^https?:\\/\\//)) continue;
+          if (!(href.startsWith('http://') || href.startsWith('https://'))) continue;
           if (href.indexOf('google.com/search') !== -1) continue;
           if (seenUrls[href]) continue;
           seenUrls[href] = true;
@@ -117,10 +126,11 @@ cli({
           }
         }
 
-        return results;
+        return {items: results};
       })()
     `);
-        if (!Array.isArray(results) || results.length === 0) {
+        const results = (wrapper && wrapper.items) || [];
+        if (results.length === 0) {
             throw new CliError('NOT_FOUND', 'No search results found', 'Try a different keyword or check for CAPTCHA');
         }
         return results;

package/clis/google-scholar/search.js

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
 
 cli({
@@ -18,12 +19,17 @@ cli({
         const limit = clampInt(kwargs.limit, 10, 1, 20);
         const query = requireNonEmptyQuery(kwargs.query);
         await page.goto(`https://scholar.google.com/scholar?q=${encodeURIComponent(query)}&hl=zh-CN`);
-        await page.wait(3);
-        const data = await page.evaluate(`
+        try {
+            await page.wait({ selector: '.gs_r.gs_or.gs_scl', timeout: 5 });
+        } catch {
+            await page.wait(3);
+        }
+        const wrapper = await page.evaluate(`
       (() => {
         const normalize = v => (v || '').replace(/\\s+/g, ' ').trim();
         const results = [];
-        for (const el of document.querySelectorAll('.gs_r.gs_or.gs_scl')) {
+        const resultCards = Array.from(document.querySelectorAll('.gs_r.gs_or.gs_scl'));
+        for (const el of resultCards) {
           const container = el.querySelector('.gs_ri') || el;
           const titleEl = container.querySelector('.gs_rt a, h3 a');
           const title = normalize(titleEl?.textContent);
@@ -50,9 +56,18 @@ cli({
           });
           if (results.length >= ${limit}) break;
         }
-        return results;
+        return { items: results, resultCount: resultCards.length };
       })()
     `);
-        return Array.isArray(data) ? data : [];
+        if (!wrapper || typeof wrapper !== 'object' || !Array.isArray(wrapper.items)) {
+            throw new CommandExecutionError('Google Scholar search returned an unexpected payload shape');
+        }
+        if (wrapper.items.length === 0) {
+            if (Number(wrapper.resultCount) > 0) {
+                throw new CommandExecutionError('Google Scholar result cards were present but no rows could be extracted');
+            }
+            throw new EmptyResultError('google-scholar/search', 'Try a different query or check whether Google Scholar returned a CAPTCHA.');
+        }
+        return wrapper.items;
     },
 });