@agentrhq/webcmd 0.4.2 → 0.4.3

package/clis/google/images.test.js

@@ -0,0 +1,375 @@
+import { describe, it, expect, vi } from 'vitest';
+import { JSDOM } from 'jsdom';
+
+const { __test__ } = await import('./images.js');
+const { command, extractGoogleImageRows, inspectGoogleImagesPage, normalizeImageRows } = __test__;
+
+function createPageMock(evaluateResult = []) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        closeWindow: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue('fresh-page'),
+        setActivePage: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(evaluateResult),
+    };
+}
+
+describe('google images', () => {
+    it('registers as a browser-backed public Google command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('google');
+        expect(command.name).toBe('images');
+        expect(command.access).toBe('read');
+        expect(command.browser).toBe(true);
+        expect(command.strategy).toBe('public');
+        expect(command.columns).toEqual(['rank', 'title', 'imageUrl', 'thumbnailUrl', 'sourceUrl', 'source', 'width', 'height']);
+        expect(command.args.find(arg => arg.name === 'resolve')).toMatchObject({
+            type: 'bool',
+            default: true,
+        });
+    });
+
+    it('rejects empty query and invalid limits before navigation', async () => {
+        const page = createPageMock();
+        await expect(command.func(page, { keyword: ' ', limit: 5 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        await expect(command.func(page, { keyword: 'webcmd', limit: 0 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        await expect(command.func(page, { keyword: 'webcmd', limit: 101 })).rejects.toMatchObject({ code: 'ARGUMENT' });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('extracts image and source URLs from Google imgres links', async () => {
+        const dom = new JSDOM(`
+          <div id="rso">
+            <a href="/imgres?imgurl=https%3A%2F%2Fcdn.example.com%2Fcat.jpg&imgrefurl=https%3A%2F%2Fexample.com%2Fcats">
+              <img alt="A tabby cat" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:abc" width="320" height="240">
+            </a>
+          </div>
+        `, { url: 'https://www.google.com/search?tbm=isch&q=cats' });
+
+        await expect(extractGoogleImageRows(5, false, dom.window.document)).resolves.toEqual([[
+            'A tabby cat',
+            'https://cdn.example.com/cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            'https://example.com/cats',
+            'example.com',
+            320,
+            240,
+        ]]);
+    });
+
+    it('falls back to visible thumbnails for dynamic image layouts', async () => {
+        const dom = new JSDOM(`
+          <div id="islrg">
+            <div data-lpage="https://example.org/post">
+              <img alt="Mountain photo" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:mountain" width="160" height="90">
+            </div>
+          </div>
+        `, { url: 'https://www.google.com/search?tbm=isch&q=mountain' });
+
+        await expect(extractGoogleImageRows(5, false, dom.window.document)).resolves.toEqual([[
+            'Mountain photo',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:mountain',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:mountain',
+            'https://example.org/post',
+            'example.org',
+            160,
+            90,
+        ]]);
+    });
+
+    it('extracts current udm=2 cards outside the legacy rso image grid', async () => {
+        const dom = new JSDOM(`
+          <div id="center_col">
+            <a href="https://shop.example.com/blue-bottle">
+              <div>
+                <img alt="Blue Bottle product" data-src="https://encrypted-tbn0.gstatic.com/images?q=tbn:blue" width="206" height="274">
+                <span>Blue Bottle product</span>
+              </div>
+            </a>
+          </div>
+        `, { url: 'https://www.google.com/search?q=blue-bottle&udm=2' });
+
+        await expect(extractGoogleImageRows(5, false, dom.window.document)).resolves.toEqual([[
+            'Blue Bottle product',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:blue',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:blue',
+            'https://shop.example.com/blue-bottle',
+            'shop.example.com',
+            206,
+            274,
+        ]]);
+    });
+
+    it('finds source links beside current Google Images cards and skips small refinement chips', async () => {
+        const dom = new JSDOM(`
+          <div role="list">
+            <a aria-label="Add Pink" href="/search?q=pink+cats&udm=2">
+              <img alt="" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:chip" width="46" height="46">
+            </a>
+          </div>
+          <div id="rso">
+            <div>
+              <div>
+                <a><img alt="10 Facts About Cats" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:cat" width="320" height="214"></a>
+                <a href="https://www.fourpawsusa.org/campaigns-topics/topics/companion-animals/10-facts-about-cats">
+                  <div>10 Facts About Cats - FOUR PAWS in US</div>
+                </a>
+              </div>
+            </div>
+          </div>
+        `, { url: 'https://www.google.com/search?tbm=isch&q=cats' });
+
+        await expect(extractGoogleImageRows(5, false, dom.window.document)).resolves.toEqual([[
+            '10 Facts About Cats',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:cat',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:cat',
+            'https://www.fourpawsusa.org/campaigns-topics/topics/companion-animals/10-facts-about-cats',
+            'fourpawsusa.org',
+            320,
+            214,
+        ]]);
+    });
+
+    it('clicks preview cards to resolve the original imgurl when requested', async () => {
+        const dom = new JSDOM(`
+          <div id="rso">
+            <div>
+              <div>
+                <div role="button">
+                  <img alt="Original cat" src="https://encrypted-tbn0.gstatic.com/images?q=tbn:cat" width="320" height="214">
+                </div>
+                <a href="https://example.com/cats"><div>Original cat</div></a>
+              </div>
+            </div>
+          </div>
+        `, {
+            url: 'https://www.google.com/search?tbm=isch&q=cats',
+            pretendToBeVisual: true,
+        });
+        const button = dom.window.document.querySelector('[role="button"]');
+        button.addEventListener('click', () => {
+            const preview = dom.window.document.createElement('a');
+            preview.href = '/imgres?imgurl=https%3A%2F%2Fcdn.example.com%2Foriginal-cat.jpg&imgrefurl=https%3A%2F%2Fexample.com%2Fcats&w=1920&h=1080';
+            dom.window.document.body.appendChild(preview);
+        });
+
+        await expect(extractGoogleImageRows(1, true, dom.window.document)).resolves.toEqual([[
+            'Original cat',
+            'https://cdn.example.com/original-cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:cat',
+            'https://example.com/cats',
+            'example.com',
+            1920,
+            1080,
+        ]]);
+    });
+
+    it('normalizes browser rows into command columns', async () => {
+        const page = createPageMock({
+            session: 'site:google',
+            data: [[
+                'A tabby cat',
+                'https://cdn.example.com/cat.jpg',
+                'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+                'https://example.com/cats',
+                'example.com',
+                320,
+                240,
+            ]],
+        });
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1 })).resolves.toEqual([{
+            rank: 1,
+            title: 'A tabby cat',
+            imageUrl: 'https://cdn.example.com/cat.jpg',
+            thumbnailUrl: 'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            sourceUrl: 'https://example.com/cats',
+            source: 'example.com',
+            width: 320,
+            height: 240,
+        }]);
+        expect(page.goto.mock.calls[0][0]).toContain('num=20');
+    });
+
+    it('retries extraction while Google Images hydrates placeholder images', async () => {
+        const page = createPageMock();
+        page.evaluate
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({
+                session: 'site:google',
+                data: [[
+                    'A tabby cat',
+                    'https://cdn.example.com/cat.jpg',
+                    'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+                    'https://example.com/cats',
+                    'example.com',
+                    320,
+                    240,
+                ]],
+            });
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1, resolve: false })).resolves.toHaveLength(1);
+
+        expect(page.evaluate).toHaveBeenCalledTimes(2);
+        expect(page.scroll).toHaveBeenCalledWith('down', 900);
+        expect(page.wait).toHaveBeenCalledWith(1);
+    });
+
+    it('drops the current tab lease and retries once when navigation is rejected', async () => {
+        const page = createPageMock([[
+            'A tabby cat',
+            'https://cdn.example.com/cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            'https://example.com/cats',
+            'example.com',
+            320,
+            240,
+        ]]);
+        page.goto
+            .mockRejectedValueOnce(new Error('Navigation rejected.'))
+            .mockResolvedValueOnce(undefined);
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1, resolve: false })).resolves.toHaveLength(1);
+
+        expect(page.goto).toHaveBeenCalledTimes(2);
+        expect(page.closeWindow).toHaveBeenCalledTimes(1);
+        expect(page.goto.mock.calls[1][0]).toContain('tbm=isch');
+    });
+
+    it('opens a fresh tab when Google Images navigation is repeatedly rejected', async () => {
+        const page = createPageMock([[
+            'A tabby cat',
+            'https://cdn.example.com/cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            'https://example.com/cats',
+            'example.com',
+            320,
+            240,
+        ]]);
+        page.goto
+            .mockRejectedValueOnce(new Error('Navigation rejected.'))
+            .mockRejectedValueOnce(new Error('Navigation rejected.'));
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1, resolve: false })).resolves.toHaveLength(1);
+
+        expect(page.goto).toHaveBeenCalledTimes(2);
+        expect(page.closeWindow).toHaveBeenCalledTimes(1);
+        expect(page.newTab).toHaveBeenCalledTimes(1);
+        expect(page.newTab.mock.calls[0][0]).toContain('tbm=isch');
+        expect(page.setActivePage).toHaveBeenCalledWith('fresh-page');
+    });
+
+    it('fails typed instead of silently returning empty rows', () => {
+        expect(() => normalizeImageRows([], 'nothing', 5)).toThrow(expect.objectContaining({ code: 'EMPTY_RESULT' }));
+        expect(() => normalizeImageRows([{ bad: true }], 'bad', 5)).toThrow(expect.objectContaining({ code: 'COMMAND_EXEC' }));
+        expect(() => normalizeImageRows([[
+            'Missing source',
+            'https://cdn.example.com/cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            '',
+            '',
+            320,
+            240,
+        ]], 'bad', 5)).toThrow(expect.objectContaining({ code: 'COMMAND_EXEC' }));
+        expect(() => normalizeImageRows([[
+            'Google internal source',
+            'https://cdn.example.com/cat.jpg',
+            'https://encrypted-tbn0.gstatic.com/images?q=tbn:abc',
+            'https://www.google.com/search?q=cats',
+            'google.com',
+            320,
+            240,
+        ]], 'bad', 5)).toThrow(expect.objectContaining({ code: 'COMMAND_EXEC' }));
+    });
+
+    it('classifies Google interstitial and explicit no-result pages', () => {
+        const captchaDom = new JSDOM(`
+          <form action="/sorry/index">
+            <div>Our systems have detected unusual traffic from your computer network.</div>
+          </form>
+        `, { url: 'https://www.google.com/search?tbm=isch&q=cats' });
+        const emptyDom = new JSDOM('<div id="center_col">No results found for impossible-query.</div>', {
+            url: 'https://www.google.com/search?tbm=isch&q=impossible-query',
+        });
+
+        expect(inspectGoogleImagesPage(captchaDom.window.document)).toMatchObject({
+            captchaOrConsent: true,
+            explicitNoResults: false,
+        });
+        expect(inspectGoogleImagesPage(emptyDom.window.document)).toMatchObject({
+            captchaOrConsent: false,
+            explicitNoResults: true,
+        });
+    });
+
+    it('typed-fails no rows unless Google exposes an explicit no-results state', async () => {
+        const page = createPageMock();
+        page.evaluate = vi.fn()
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({
+                session: 'site:google',
+                data: {
+                    hasResultRoot: true,
+                    hasImageCandidates: true,
+                    captchaOrConsent: false,
+                    explicitNoResults: false,
+                },
+            });
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1, resolve: false }))
+            .rejects.toThrow(expect.objectContaining({ code: 'COMMAND_EXEC' }));
+    });
+
+    it('preserves true no-results as EmptyResultError when explicit marker is visible', async () => {
+        const page = createPageMock();
+        page.evaluate = vi.fn()
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({
+                session: 'site:google',
+                data: {
+                    hasResultRoot: true,
+                    hasImageCandidates: false,
+                    captchaOrConsent: false,
+                    explicitNoResults: true,
+                },
+            });
+
+        await expect(command.func(page, { keyword: 'impossible-query', limit: 1, resolve: false }))
+            .rejects.toThrow(expect.objectContaining({ code: 'EMPTY_RESULT' }));
+    });
+
+    it('typed-fails CAPTCHA or consent pages instead of reporting empty image results', async () => {
+        const page = createPageMock();
+        page.evaluate = vi.fn()
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({ session: 'site:google', data: [] })
+            .mockResolvedValueOnce({
+                session: 'site:google',
+                data: {
+                    hasResultRoot: false,
+                    hasImageCandidates: false,
+                    captchaOrConsent: true,
+                    explicitNoResults: false,
+                },
+            });
+
+        await expect(command.func(page, { keyword: 'cats', limit: 1, resolve: false }))
+            .rejects.toThrow(expect.objectContaining({ code: 'COMMAND_EXEC' }));
+    });
+});

package/clis/instagram/user.js

@@ -18,22 +18,14 @@ cli({
   const headers = { 'X-IG-App-ID': '936619743392459' };
   const opts = { credentials: 'include', headers };
 
-  // Get user ID first
-  const r1 = await fetch(
-    'https://www.instagram.com/api/v1/users/web_profile_info/?username=' + encodeURIComponent(username),
-    opts
-  );
-  if (!r1.ok) throw new Error('HTTP ' + r1.status + ' - make sure you are logged in to Instagram');
-  const d1 = await r1.json();
-  const userId = d1?.data?.user?.id;
-  if (!userId) throw new Error('User not found: ' + username);
-
-  // Get user feed
+  // Fetch directly by username. web_profile_info is gated for some public
+  // accounts even with a valid session, while this feed endpoint still returns
+  // the same media item shape this command maps.
   const r2 = await fetch(
-    'https://www.instagram.com/api/v1/feed/user/' + userId + '/?count=' + limit,
+    'https://www.instagram.com/api/v1/feed/user/' + encodeURIComponent(username) + '/username/?count=' + limit,
     opts
   );
-  if (!r2.ok) throw new Error('Failed to fetch user feed: HTTP ' + r2.status);
+  if (!r2.ok) throw new Error('HTTP ' + r2.status + ' - make sure you are logged in to Instagram');
   const d2 = await r2.json();
   return (d2?.items || []).slice(0, limit).map((p, i) => ({
     index: i + 1,

package/clis/instagram/user.test.js

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@agentrhq/webcmd/registry';
+import './user.js';
+
+function getUserEvaluateJs() {
+  const cmd = getRegistry().get('instagram/user');
+  const evalStep = cmd.pipeline.find((s) => s.evaluate);
+  return evalStep.evaluate;
+}
+
+async function runUserEvaluate(fetchFn, args = { username: 'sleepcycleapp', limit: 2 }) {
+  const js = getUserEvaluateJs()
+    .replace('${{ args.username | json }}', JSON.stringify(args.username))
+    .replace('${{ args.limit }}', String(args.limit));
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = fetchFn;
+  try {
+    return await eval(js);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+}
+
+describe('instagram/user feed fetch', () => {
+  it('fetches recent posts directly by username', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        items: [
+          {
+            caption: { text: 'First post\nwith newline' },
+            like_count: 12,
+            comment_count: 3,
+            media_type: 1,
+            taken_at: 1784451600,
+          },
+          {
+            caption: { text: 'Second post' },
+            like_count: 4,
+            comment_count: 1,
+            media_type: 2,
+          },
+        ],
+      }),
+    });
+
+    const result = await runUserEvaluate(fetchFn, { username: 'sleep cycle/app', limit: 2 });
+
+    expect(fetchFn).toHaveBeenCalledTimes(1);
+    expect(fetchFn.mock.calls[0][0]).toBe('https://www.instagram.com/api/v1/feed/user/sleep%20cycle%2Fapp/username/?count=2');
+    expect(fetchFn.mock.calls[0][1]).toMatchObject({
+      credentials: 'include',
+      headers: { 'X-IG-App-ID': '936619743392459' },
+    });
+    expect(fetchFn.mock.calls[0][0]).not.toContain('web_profile_info');
+    expect(result).toEqual([
+      { index: 1, caption: 'First post with newline', likes: 12, comments: 3, type: 'photo', date: expect.any(String) },
+      { index: 2, caption: 'Second post', likes: 4, comments: 1, type: 'video', date: '' },
+    ]);
+  });
+
+  it('keeps the login-oriented error for failed feed requests', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({ ok: false, status: 400 });
+    await expect(runUserEvaluate(fetchFn)).rejects.toThrow('HTTP 400 - make sure you are logged in to Instagram');
+  });
+});

package/clis/mercury/check-login.js

@@ -11,7 +11,6 @@ cli({
     strategy: Strategy.UI,
     browser: true,
     siteSession: 'persistent',
-    defaultWindowMode: 'foreground',
     navigateBefore: false,
     args: [],
     columns: ['status', 'loggedIn', 'url', 'hasSubmitExpense', 'hasReimbursements', 'title'],

package/clis/mercury/reimbursement-draft.js

@@ -23,7 +23,6 @@ cli({
     strategy: Strategy.UI,
     browser: true,
     siteSession: 'persistent',
-    defaultWindowMode: 'foreground',
     navigateBefore: false,
     args: [
         {

package/clis/practo/book-confirm.js

@@ -11,7 +11,6 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   navigateBefore: false,
-  defaultWindowMode: 'foreground',
   siteSession: 'persistent',
   args: [
     { name: 'practice_doctor_id', positional: true, required: true, help: 'Practo practice_doctor_id' },

package/clis/practo/cancel.js

@@ -11,7 +11,6 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   navigateBefore: false,
-  defaultWindowMode: 'foreground',
   siteSession: 'persistent',
   args: [
     { name: 'appointment_id', positional: true, required: true, help: 'Appointment id from `practo appointments`' },

package/clis/trip/attraction.js

@@ -0,0 +1,74 @@
+/**
+ * Trip.com (international) attractions and experiences search by destination
+ * keyword.
+ *
+ * The things-to-do products load client-side into hashed CSS-module cards, so
+ * this anchors on each card's stable `things-to-do/detail/<id>` link (which also
+ * gives a real per-row `url`) and reads rating / reviews / booked / price from
+ * the card text by data-format pattern (see `buildAttractionExtractJs` in utils).
+ */
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_ATTRACTIONS_JS,
+    buildAttractionExtractJs,
+    buildAttractionSearchUrl,
+    parseKeyword,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'attraction',
+    access: 'read',
+    description: 'Search Trip.com attractions and experiences by destination keyword',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Destination or attraction keyword (e.g. Tokyo / Paris / Louvre)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of results (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'name',
+        'rating', 'reviews', 'booked',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const query = parseKeyword('query', kwargs.query);
+        const limit = parseListLimit(kwargs.limit);
+
+        const searchUrl = buildAttractionSearchUrl(query);
+        await page.goto(searchUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_ATTRACTIONS_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 === 'empty') {
+            throw new EmptyResultError('trip attraction', `No attractions for "${query}"`);
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com things-to-do page did not render product cards (state=${String(waitResult)})`);
+        }
+        const raw = await page.evaluate(buildAttractionExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com attraction DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new CommandExecutionError('Trip.com attraction cards rendered but parser did not find required detail-link anchors');
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            name: r.name,
+            rating: r.rating,
+            reviews: r.reviews,
+            booked: r.booked,
+            price: r.price,
+            currency: 'USD',
+            url: r.url,
+        }));
+    },
+});

package/clis/trip/car.js

@@ -0,0 +1,74 @@
+/**
+ * Trip.com (international) car-rental listing by city.
+ *
+ * Trip.com files car-rental listings under an SEO path whose text slugs are
+ * cosmetic; only the numeric carhire city id routes the page, so this takes that
+ * id (discover it via the carhire search box) and reads the rendered `.card-item`
+ * cards by stable class fields (see `buildCarExtractJs` in utils). The listing
+ * carries the site's near-term representative daily price; a dated pickup /
+ * drop-off quote sits behind the booking step and is out of scope here.
+ */
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@agentrhq/webcmd/errors';
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+import {
+    WAIT_FOR_CARS_JS,
+    buildCarExtractJs,
+    buildCarListUrl,
+    parseCityId,
+    parseListLimit,
+} from './utils.js';
+
+cli({
+    site: 'trip',
+    name: 'car',
+    access: 'read',
+    description: 'List Trip.com car-rental vehicles for a city (category, model, seats, daily price)',
+    domain: 'trip.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'city', required: true, positional: true, help: 'Numeric Trip.com carhire city id (discover via the carhire search box)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of vehicles (1-50)' },
+    ],
+    columns: [
+        'rank',
+        'category', 'vehicle',
+        'seats',
+        'price', 'currency',
+        'url',
+    ],
+    func: async (page, kwargs) => {
+        const cityId = parseCityId('city', kwargs.city);
+        const limit = parseListLimit(kwargs.limit);
+
+        const listUrl = buildCarListUrl(cityId);
+        await page.goto(listUrl);
+        const waitResult = await page.evaluate(WAIT_FOR_CARS_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 === 'empty') {
+            throw new EmptyResultError('trip car', `No car rentals for city id ${cityId}`);
+        }
+        if (waitResult !== 'content') {
+            throw new CommandExecutionError(`Trip.com car listing did not render (state=${String(waitResult)}); check the carhire city id`);
+        }
+        const raw = await page.evaluate(buildCarExtractJs());
+        if (!Array.isArray(raw)) {
+            throw new CommandExecutionError('Trip.com car DOM extraction returned malformed rows');
+        }
+        if (raw.length === 0) {
+            throw new CommandExecutionError('Trip.com car cards rendered but parser did not find required price anchors');
+        }
+        return raw.slice(0, limit).map((r, i) => ({
+            rank: i + 1,
+            category: r.category,
+            vehicle: r.vehicle,
+            seats: r.seats,
+            price: r.price,
+            currency: r.currency,
+            url: listUrl,
+        }));
+    },
+});