@agentrhq/webcmd 0.4.1 → 0.4.3

package/clis/trip/deals.js

@@ -0,0 +1,61 @@
+/**
+ * Trip.com (international) running-promotions listing.
+ *
+ * Trip.com curates its live campaigns on a "Today's Top Deals" hub
+ * (`/sale/deals/`), each a promo tile linking to a dedicated campaign page. The
+ * hub renders client-side, so this reads the rendered `.top-deals_link-item`
+ * tiles (title, offer line, parsed discount, campaign URL) the same way the other
+ * browser-mode trip commands read their result cards. The per-campaign terms and
+ * bookable inventory live on the linked page and are out of scope here.
+ */
+import { AuthRequiredError, CommandExecutionError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { WAIT_FOR_DEALS_JS, buildDealsExtractJs, buildDealsUrl, parseListLimit } from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'deals',
+    access: 'read',
+    description: 'List Trip.com live promotions from the Top Deals hub: campaign title, offer, discount, and link',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of deals (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'title', 'offer',
+        'discount',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const limit = parseListLimit(kwargs.limit);
+
+        await page.goto(buildDealsUrl());
+        const waitResult = await page.evaluate(WAIT_FOR_DEALS_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com deals page did not render deal tiles (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(buildDealsExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com deals DOM extraction returned malformed rows');
+        }
+        // The Top Deals hub is a permanent curated page, so once the wait confirms it
+        // rendered, zero parsed tiles means the tile markup drifted, not an empty hub.
+        if (raw.length === 0) {
+            throw new CommandExecutionError('Trip.com deals hub rendered but no promotion tiles parsed (the tile markup may have changed)');
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            title: r.title,
+            offer: r.offer,
+            discount: r.discount,
+            url: r.url,
+        }));
+    },
+});

package/clis/trip/flight-round.js

@@ -0,0 +1,88 @@
+/**
+ * Trip.com (international) round-trip flight search by IATA route + dates.
+ *
+ * Complements one-way `flight`: the round-trip results page renders the same
+ * `.result-item` outbound cards (priced for the round trip), so this reuses the
+ * shared flight extractor and wait helper against a `triptype=rt` search URL.
+ * Rows missing the airline, both airports, or both times are dropped.
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_FLIGHTS_JS,
+    buildFlightExtractJs,
+    buildFlightRoundSearchUrl,
+    parseIataCode,
+    parseIsoDate,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'flight-round',
+    access: 'read',
+    description: 'Search Trip.com round-trip flights by IATA route + depart/return dates',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'from', required: true, positional: true, help: 'Departure IATA code (e.g. LON / LHR)' },
+        { name: 'to', required: true, positional: true, help: 'Arrival IATA code (e.g. NYC / JFK)' },
+        { name: 'depart', required: true, help: 'Outbound date (YYYY-MM-DD)' },
+        { name: 'return', required: true, help: 'Return date (YYYY-MM-DD)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of flights (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'airline',
+        'departureTime', 'departureAirport',
+        'arrivalTime', 'arrivalAirport',
+        'duration', 'stops',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const fromCode = parseIataCode('from', kwargs.from);
+        const toCode = parseIataCode('to', kwargs.to);
+        if (fromCode === toCode) {
+            throw new ArgumentError(`--from and --to must differ (got ${fromCode})`);
+        }
+        const depart = parseIsoDate('depart', kwargs.depart);
+        const ret = parseIsoDate('return', kwargs.return);
+        if (depart >= ret) {
+            throw new ArgumentError(`--depart must be before --return (got ${depart} .. ${ret})`);
+        }
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildFlightRoundSearchUrl(fromCode, toCode, depart, ret);
+        await page.goto(searchUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_FLIGHTS_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com flight page did not render flight cards (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(buildFlightExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com flight DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new EmptyResultError('trip flight-round', `No round-trip flights for ${fromCode} to ${toCode} on ${depart} .. ${ret}`);
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            airline: r.airline,
+            departureTime: r.departureTime,
+            departureAirport: r.departureAirport,
+            arrivalTime: r.arrivalTime,
+            arrivalAirport: r.arrivalAirport,
+            duration: r.duration,
+            stops: r.stops,
+            price: r.price,
+            currency: r.currency,
+            url: searchUrl,
+        }));
+    },
+});

package/clis/trip/flight.js

@@ -0,0 +1,83 @@
+/**
+ * Trip.com (international) one-way flight search by IATA route + date.
+ *
+ * Trip.com is the English-facing sibling of Ctrip. Results render client-side
+ * into `.result-item` cards keyed by stable `data-testid` anchors, so this
+ * reads by selector (see `buildFlightExtractJs` in utils) rather than by
+ * position. Rows missing the airline, both airports, or both times are dropped.
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_FLIGHTS_JS,
+    buildFlightExtractJs,
+    buildFlightSearchUrl,
+    parseIataCode,
+    parseIsoDate,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'flight',
+    access: 'read',
+    description: 'Search Trip.com one-way flights by IATA route + departure date',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'from', required: true, positional: true, help: 'Departure IATA code (e.g. LON / LHR)' },
+        { name: 'to', required: true, positional: true, help: 'Arrival IATA code (e.g. NYC / JFK)' },
+        { name: 'date', required: true, help: 'Departure date (YYYY-MM-DD)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of flights (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'airline',
+        'departureTime', 'departureAirport',
+        'arrivalTime', 'arrivalAirport',
+        'duration', 'stops',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const fromCode = parseIataCode('from', kwargs.from);
+        const toCode = parseIataCode('to', kwargs.to);
+        if (fromCode === toCode) {
+            throw new ArgumentError(`--from and --to must differ (got ${fromCode})`);
+        }
+        const date = parseIsoDate('date', kwargs.date);
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildFlightSearchUrl(fromCode, toCode, date);
+        await page.goto(searchUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_FLIGHTS_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com flight page did not render flight cards (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(buildFlightExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com flight DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new EmptyResultError('trip flight', `No flights for ${fromCode} to ${toCode} on ${date}`);
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            airline: r.airline,
+            departureTime: r.departureTime,
+            departureAirport: r.departureAirport,
+            arrivalTime: r.arrivalTime,
+            arrivalAirport: r.arrivalAirport,
+            duration: r.duration,
+            stops: r.stops,
+            price: r.price,
+            currency: r.currency,
+            url: searchUrl,
+        }));
+    },
+});

package/clis/trip/hotel-search.js

@@ -0,0 +1,80 @@
+/**
+ * Trip.com (international) hotel listing by city id + check-in/out date range.
+ *
+ * Trip.com renders hotel results client-side into `.hotel-card` cards keyed by
+ * stable class fields, so this reads by selector (see `buildHotelExtractJs` in
+ * utils) rather than positional innerText. Cards without a hotel name are
+ * dropped rather than surfaced with blanks.
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_HOTELS_JS,
+    buildHotelExtractJs,
+    buildHotelSearchUrl,
+    parseCityId,
+    parseIsoDate,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'hotel-search',
+    access: 'read',
+    description: 'List Trip.com hotels for a city id + check-in/out date range',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'city', required: true, positional: true, help: 'Numeric Trip.com city id (discover via the hotels search box; e.g. 338 for London)' },
+        { 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: 20, help: 'Number of hotels (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'name', 'score', 'reviewLabel', 'reviews',
+        'location', 'room',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const cityId = parseCityId('city', kwargs.city);
+        const checkin = parseIsoDate('checkin', kwargs.checkin);
+        const checkout = parseIsoDate('checkout', kwargs.checkout);
+        if (checkin >= checkout) {
+            throw new ArgumentError(`--checkin must be before --checkout (got ${checkin} .. ${checkout})`);
+        }
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildHotelSearchUrl(cityId, checkin, checkout);
+        await page.goto(searchUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_HOTELS_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com hotel page did not render hotel cards (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(buildHotelExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com hotel DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new EmptyResultError('trip hotel-search', `No hotels for city ${cityId} on ${checkin} .. ${checkout}`);
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            name: r.name,
+            score: r.score,
+            reviewLabel: r.reviewLabel,
+            reviews: r.reviews,
+            location: r.location,
+            room: r.room,
+            price: r.price,
+            currency: r.currency,
+            url: searchUrl,
+        }));
+    },
+});

package/clis/trip/hotel.js

@@ -0,0 +1,54 @@
+/**
+ * Trip.com (international) single-hotel detail by id: rating breakdown, popular
+ * amenities, check-in/out policy, address, and coordinates.
+ *
+ * Reads `__NEXT_DATA__.props.pageProps.hotelDetailResponse` from the SSR detail
+ * page, the same SSR shape the mainland `ctrip hotel` detail uses. This surfaces
+ * the fields the `hotel-search` list row does not carry. Room-level nightly
+ * prices load via a post-SSR XHR and are out of scope here; `hotel-search`
+ * already reports a representative nightly price per hotel.
+ */
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { WAIT_FOR_HOTEL_DETAIL_JS, buildHotelDetailExtractJs, buildHotelDetailUrl, parseHotelId } from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'hotel',
+    access: 'read',
+    description: 'Show a Trip.com hotel detail by id (rating breakdown, amenities, check-in/out policy)',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Numeric Trip.com hotel id (discover via the hotels list; e.g. 715233)' },
+    ],
+    columns: [
+        'hotelId', 'name', 'enName',
+        'star', 'score', 'scoreLabel', 'reviewCount', 'ratingBreakdown',
+        'facilities', 'checkInOut',
+        'cityName', 'address', 'lat', 'lon',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const hotelId = parseHotelId('id', kwargs.id);
+        const url = buildHotelDetailUrl(hotelId);
+        await page.goto(url);
+        const waitResult = await page.evaluate(WAIT_FOR_HOTEL_DETAIL_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com hotel detail page did not expose SSR hotel data (state=${String(waitResult)})`);
+        }
+        const detail = await page.evaluate(buildHotelDetailExtractJs());
+        if (!detail || typeof detail !== 'object') {
+            throw new CommandExecutionError('Trip.com hotel detail SSR extraction returned malformed data');
+        }
+        if (!detail.hotelId || !detail.name) {
+            throw new EmptyResultError('trip hotel', `No detail exposed for hotel id ${hotelId}`);
+        }
+        return [{ ...detail, url }];
+    },
+});

package/clis/trip/package.js

@@ -0,0 +1,93 @@
+/**
+ * Trip.com (international) flight+hotel package search by route + dates.
+ *
+ * Trip.com prices its packages through the flight-selection step of the booking
+ * flow: a public, unsigned POST keyed on the metro city codes plus the
+ * destination hotel city id returns the outbound flight options priced at the
+ * bundle rate (the specific hotel is picked in a later step). So this is a plain
+ * public fetch (no browser) that resolves both endpoints through the same POI
+ * search `trip search` uses, then lists the package flights (see
+ * `fetchPackageSearch` in utils). Per-person package fares only; the return leg
+ * rides on the hotel checkout date.
+ */
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { fetchPackageSearch, mapPackageRow, parseIsoDate, parseKeyword, parseListLimit, resolvePackageCity } from './utils.js';
+
+function parseAdults(raw) {
+    if (raw === undefined || raw === null || raw === '') return 2;
+    const parsed = Number(raw);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 9) {
+        throw new ArgumentError(`--adults must be an integer between 1 and 9, got ${JSON.stringify(raw)}`);
+    }
+    return parsed;
+}
+
+cli({
+    site: 'trip',
+    name: 'package',
+    access: 'read',
+    description: 'Search Trip.com flight+hotel packages by route + dates; lists the package flight options priced at the bundle rate',
+    domain: 'trip.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'from', required: true, positional: true, help: 'Origin city keyword (e.g. Seoul / London / Bangkok)' },
+        { name: 'to', required: true, positional: true, help: 'Destination city keyword (e.g. Tokyo / Paris / Singapore)' },
+        { name: 'depart', required: true, help: 'Outbound date (YYYY-MM-DD)' },
+        { name: 'return', required: true, help: 'Return date (YYYY-MM-DD)' },
+        { name: 'adults', type: 'int', default: 2, help: 'Number of adults (1-9, default 2)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of packages (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'airline', 'flightNo',
+        'from', 'to',
+        'departure', 'arrival',
+        'stops',
+        'price', 'currency',
+    ],
+    func: async (kwargs) => {
+        const from = parseKeyword('from', kwargs.from);
+        const to = parseKeyword('to', kwargs.to);
+        const depart = parseIsoDate('depart', kwargs.depart);
+        const ret = parseIsoDate('return', kwargs.return);
+        if (depart >= ret) {
+            throw new ArgumentError(`--depart must be before --return (got ${depart} .. ${ret})`);
+        }
+        const adults = parseAdults(kwargs.adults);
+        const limit = parseListLimit(kwargs.limit);
+
+        const origin = await resolvePackageCity(from);
+        if (!origin) {
+            throw new ArgumentError(`Could not resolve origin "${from}" to a Trip.com city; run 'trip search ${from}' to find the name`);
+        }
+        const dest = await resolvePackageCity(to);
+        if (!dest) {
+            throw new ArgumentError(`Could not resolve destination "${to}" to a Trip.com city; run 'trip search ${to}' to find the name`);
+        }
+        if (origin.cityId === dest.cityId) {
+            throw new ArgumentError(`--from and --to must differ (both resolved to ${dest.name})`);
+        }
+
+        const groups = await fetchPackageSearch({
+            dcode: origin.cityCode,
+            acode: dest.cityCode,
+            hcityid: String(dest.cityId),
+            depart,
+            ret,
+            adults,
+        });
+        if (groups.length === 0) {
+            throw new EmptyResultError('trip package', `No flight+hotel packages for ${origin.name} to ${dest.name} on ${depart} .. ${ret}`);
+        }
+        const rows = groups
+            .filter((g) => g && Array.isArray(g.flightlist) && g.flightlist.length)
+            .map((g) => mapPackageRow(g, 0))
+            .filter((row) => row.flightNo && row.from && row.to && row.departure && row.arrival);
+        if (rows.length === 0) {
+            throw new CommandExecutionError(`Trip.com package search returned ${groups.length} group(s) but none carried a parseable flight identity, route, and time`);
+        }
+        return rows.slice(0, limit).map((row, i) => ({ ...row, rank: i + 1 }));
+    },
+});

package/clis/trip/search.js

@@ -0,0 +1,43 @@
+/**
+ * Trip.com (international) destination suggest.
+ *
+ * Trip.com's flight / hotel search boxes resolve a keyword through a public,
+ * unsigned POI-search endpoint, so this is a plain public fetch (no browser) that
+ * returns the city / airport matches. The `cityId` feeds `hotel-search` / `car` /
+ * `tour`, and the `airportCode` feeds `flight` / `transfer`, so `search` is the
+ * discovery step for the id-based commands (see `fetchPoiSearch` in utils).
+ */
+import { EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { fetchPoiSearch, flattenPoiResults, mapSearchRow, parseKeyword, parseListLimit } from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'search',
+    access: 'read',
+    description: 'Suggest Trip.com destinations (cities, airports) for a keyword; resolves the ids the other commands take',
+    domain: 'trip.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Destination keyword (e.g. Tokyo / Bali / London)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of suggestions (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'name', 'type',
+        'cityId', 'airportCode',
+        'province', 'country',
+    ],
+    func: async (kwargs) => {
+        const query = parseKeyword('query', kwargs.query);
+        const limit = parseListLimit(kwargs.limit);
+
+        const results = await fetchPoiSearch(query);
+        const items = flattenPoiResults(results).filter((item) => item && item.name);
+        if (items.length === 0) {
+            throw new EmptyResultError('trip search', `No destinations for "${query}"`);
+        }
+        return items.slice(0, limit).map((item, i) => mapSearchRow(item, i));
+    },
+});

package/clis/trip/tour.js

@@ -0,0 +1,84 @@
+/**
+ * Trip.com (international) tour-package search by destination keyword.
+ *
+ * Trip.com's tour results (`package-tours/list?kwd=<keyword>`) load through a
+ * signed POST that only fires on a search submit, so this navigates the results
+ * page and lets the page issue its own signed request while a fetch hook captures
+ * the `products` response, rather than replaying the signature (see
+ * `buildTourSearchJs` in utils). Per-departure pricing and availability sit behind
+ * the booking step; the row `price` is the starting per-person estimate shown.
+ */
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import { buildTourSearchJs, buildTourSearchUrl, parseKeyword, parseListLimit } from './utils.js';
+
+const TOUR_TABS = { private: 'privateTours', group: 'groupTours' };
+
+function parseTourType(raw) {
+    if (raw === undefined || raw === null || raw === '') return TOUR_TABS.private;
+    const value = String(raw).trim().toLowerCase();
+    if (!TOUR_TABS[value]) {
+        throw new ArgumentError(`--type must be private or group, got ${JSON.stringify(raw)}`);
+    }
+    return TOUR_TABS[value];
+}
+
+cli({
+    site: 'trip',
+    name: 'tour',
+    access: 'read',
+    description: 'Search Trip.com tour packages by destination keyword (private or group tours)',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Destination or tour keyword (e.g. Tokyo / Kyoto / Bali)' },
+        { name: 'type', default: 'private', help: 'Tour line: private or group (default private)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of tours (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'name', 'type',
+        'rating', 'reviews',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const query = parseKeyword('query', kwargs.query);
+        const tourType = parseTourType(kwargs.type);
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildTourSearchUrl(query, tourType);
+        await page.goto(searchUrl);
+        const result = await page.evaluate(buildTourSearchJs(query));
+        if (!result || typeof result !== 'object') {
+            throw new CommandExecutionError('Trip.com tour search returned malformed data');
+        }
+        if (result.status === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (result.status === 'empty') {
+            throw new EmptyResultError('trip tour', `No ${kwargs.type || 'private'} tours for "${query}"`);
+        }
+        if (result.status !== 'content') {
+            throw new CommandExecutionError(`Trip.com tour search did not return results (state=${String(result.status)})`);
+        }
+        // Products captured but none carry a name is drift (schema moved), not an empty search;
+        // a genuine no-match resolves as status 'empty' above off the page's "0 routes found".
+        const rows = Array.isArray(result.rows) ? result.rows.filter((r) => r.name) : [];
+        if (rows.length === 0) {
+            throw new CommandExecutionError('Trip.com tour search captured products but none carried a name (the product markup may have changed)');
+        }
+        return rows.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            name: r.name,
+            type: r.type,
+            rating: r.rating,
+            reviews: r.reviews,
+            price: r.price,
+            currency: 'USD',
+            url: r.url,
+        }));
+    },
+});

package/clis/trip/train.js

@@ -0,0 +1,76 @@
+/**
+ * Trip.com (international) train timetable by route.
+ *
+ * Trip.com exposes per-route SEO timetables at
+ * `trains/<country>/route/<from>-to-<to>/`, so `--country` is required and the
+ * city names are slugified into the URL. The page lists journeys as timetable
+ * rows (departure / arrival times, stations, duration, changes) read by stable
+ * class fields (see `buildTrainExtractJs` in utils); per-journey fares sit behind
+ * the booking step and are out of scope here.
+ */
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_TRAINS_JS,
+    buildTrainExtractJs,
+    buildTrainRouteUrl,
+    parseKeyword,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'train',
+    access: 'read',
+    description: 'Show a Trip.com train route timetable (departure/arrival times, duration, changes)',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'from', required: true, positional: true, help: 'Departure city (e.g. London / Paris / Shanghai)' },
+        { name: 'to', required: true, positional: true, help: 'Arrival city (e.g. Manchester / Lyon / Beijing)' },
+        { name: 'country', required: true, help: 'Route country slug (e.g. uk / france / italy / spain / germany / china)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of journeys (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'departureTime', 'fromStation',
+        'arrivalTime', 'toStation',
+        'duration', 'changes',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const from = parseKeyword('from', kwargs.from);
+        const to = parseKeyword('to', kwargs.to);
+        const country = parseKeyword('country', kwargs.country);
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildTrainRouteUrl(country, from, to);
+        await page.goto(searchUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_TRAINS_JS);
+        if (waitResult === 'captcha') {
+            throw new AuthRequiredError('trip.com', 'Trip.com is asking for a verification; complete it in your browser session and retry');
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com train timetable did not render (state=${String(waitResult)}); check the city names and --country`);
+        }
+        const raw = await page.evaluate(buildTrainExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com train DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new EmptyResultError('trip train', `No timetable for ${from} to ${to} (${country})`);
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            departureTime: r.departureTime,
+            fromStation: r.fromStation,
+            arrivalTime: r.arrivalTime,
+            toStation: r.toStation,
+            duration: r.duration,
+            changes: r.changes,
+            url: searchUrl,
+        }));
+    },
+});