@jackwener/opencli 1.7.12 → 1.7.14

package/clis/crates/crate.js

@@ -0,0 +1,62 @@
+// crates crate — fetch a single crate's metadata.
+//
+// Hits `https://crates.io/api/v1/crates/<name>`. Returns the agent-useful
+// projection: name, latest version, description, total + recent downloads,
+// homepage / docs / repo, license (from latest version row), version count,
+// created / updated timestamps.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { CRATES_BASE, cratesFetch, requireCrateName } from './utils.js';
+
+cli({
+    site: 'crates',
+    name: 'crate',
+    access: 'read',
+    description: 'Single crates.io crate metadata (latest version, downloads, license, repo)',
+    domain: 'crates.io',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'name', positional: true, required: true, help: 'crates.io crate name (e.g. "serde", "tokio")' },
+    ],
+    columns: [
+        'name', 'latestVersion', 'description', 'downloads', 'recentDownloads', 'versions',
+        'license', 'homepage', 'documentation', 'repository', 'keywords', 'categories', 'created', 'updated', 'url',
+    ],
+    func: async (args) => {
+        const name = requireCrateName(args.name);
+        const body = await cratesFetch(`${CRATES_BASE}/api/v1/crates/${encodeURIComponent(name)}`, `crates crate ${name}`);
+        const c = body?.crate;
+        if (!c || !c.id) {
+            throw new EmptyResultError('crates crate', `crates.io returned no metadata for "${name}".`);
+        }
+        const versions = Array.isArray(body.versions) ? body.versions : [];
+        const latestRow = versions.find((v) => v.num === c.newest_version)
+            || versions.find((v) => v.num === c.max_stable_version)
+            || versions[0]
+            || {};
+        const keywords = Array.isArray(body.keywords)
+            ? body.keywords.map((k) => k?.keyword || k?.id || '').filter(Boolean).join(', ')
+            : '';
+        const categories = Array.isArray(body.categories)
+            ? body.categories.map((cat) => cat?.category || cat?.slug || '').filter(Boolean).join(', ')
+            : '';
+        return [{
+            name: String(c.name ?? c.id),
+            latestVersion: String(c.newest_version ?? c.max_stable_version ?? c.max_version ?? ''),
+            description: String(c.description ?? '').trim(),
+            downloads: c.downloads != null ? Number(c.downloads) : null,
+            recentDownloads: c.recent_downloads != null ? Number(c.recent_downloads) : null,
+            versions: c.num_versions != null ? Number(c.num_versions) : versions.length,
+            license: String(latestRow.license ?? ''),
+            homepage: String(c.homepage ?? ''),
+            documentation: String(c.documentation ?? ''),
+            repository: String(c.repository ?? ''),
+            keywords,
+            categories,
+            created: String(c.created_at ?? '').slice(0, 10),
+            updated: String(c.updated_at ?? '').slice(0, 10),
+            url: `https://crates.io/crates/${c.name ?? c.id}`,
+        }];
+    },
+});

package/clis/crates/search.js

@@ -0,0 +1,44 @@
+// crates search — search the crates.io registry by free-text query.
+//
+// Hits `https://crates.io/api/v1/crates?q=…&per_page=…`. Returns name (round-
+// trips into `crates crate`), latest version, description, downloads, recent
+// downloads, repository, last-update.
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { CRATES_BASE, cratesFetch, requireBoundedInt, requireString } from './utils.js';
+
+cli({
+    site: 'crates',
+    name: 'search',
+    access: 'read',
+    description: 'Search the public crates.io registry by keyword',
+    domain: 'crates.io',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', positional: true, required: true, help: 'Search keyword (e.g. "serde", "async runtime")' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results (1-100)' },
+    ],
+    columns: ['rank', 'name', 'latestVersion', 'description', 'downloads', 'recentDownloads', 'repository', 'updated', 'url'],
+    func: async (args) => {
+        const query = requireString(args.query, 'query');
+        const limit = requireBoundedInt(args.limit, 20, 100);
+        const url = `${CRATES_BASE}/api/v1/crates?q=${encodeURIComponent(query)}&per_page=${limit}`;
+        const body = await cratesFetch(url, 'crates search');
+        const list = Array.isArray(body?.crates) ? body.crates : [];
+        if (!list.length) {
+            throw new EmptyResultError('crates search', `No crates.io results matched "${query}".`);
+        }
+        return list.slice(0, limit).map((c, i) => ({
+            rank: i + 1,
+            name: String(c.name ?? c.id ?? ''),
+            latestVersion: String(c.newest_version ?? c.max_stable_version ?? c.max_version ?? ''),
+            description: String(c.description ?? '').trim(),
+            downloads: c.downloads != null ? Number(c.downloads) : null,
+            recentDownloads: c.recent_downloads != null ? Number(c.recent_downloads) : null,
+            repository: String(c.repository ?? c.homepage ?? ''),
+            updated: String(c.updated_at ?? '').slice(0, 10),
+            url: c.name ? `https://crates.io/crates/${c.name}` : '',
+        }));
+    },
+});

package/clis/crates/utils.js

@@ -0,0 +1,72 @@
+// Shared helpers for the crates.io adapters.
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const CRATES_BASE = 'https://crates.io';
+const UA = 'opencli-crates-adapter (+https://github.com/jackwener/opencli)';
+
+// crates.io crate names: 1-64 chars, ascii letters/digits/-_, must start with a letter.
+const CRATE_NAME = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`crates ${label} cannot be empty`);
+    return s;
+}
+
+export function requireCrateName(value) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError('crates crate name is required (e.g. "serde", "tokio")');
+    if (!CRATE_NAME.test(s)) {
+        throw new ArgumentError(
+            `crates crate name "${value}" is not a valid crates.io name`,
+            'Names start with an ASCII letter, then 0-63 chars of letters / digits / "_-".',
+        );
+    }
+    return s;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`crates ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`crates ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function cratesFetch(url, label) {
+    let resp;
+    try {
+        // crates.io requires a descriptive User-Agent per https://crates.io/data-access
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that crates.io is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `crates.io returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'crates.io rate-limits unauthenticated traffic; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}

package/clis/ctrip/ctrip.test.js

@@ -0,0 +1,234 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+import './hotel-suggest.js';
+import { buildUrl, mapSuggestRow, parseLimit, pickCoords } from './utils.js';
+
+function ok(payload) {
+    return new Response(JSON.stringify(payload), { status: 200 });
+}
+
+const SHANGHAI_CITY = {
+    id: '2', type: 'City', word: '上海', cityId: 2, cityName: '上海',
+    provinceName: '上海', countryName: '中国', cityEName: 'Shanghai',
+    countryEName: 'China', displayName: '上海, 中国', displayType: '城市',
+    eName: 'Shanghai', commentScore: 0,
+    lat: 0, lon: 0, gLat: 0, gLon: 0, gdLat: 31.2304, gdLon: 121.4737,
+};
+
+const FORBIDDEN_CITY = {
+    id: '4189051', type: 'Markland', word: '故宫博物院', cityId: 1, cityName: '北京',
+    provinceName: '北京', countryName: '中国', displayName: '故宫博物院, 北京, 中国',
+    displayType: '地标', eName: 'The Palace Museum', commentScore: 4.8, cStar: 0,
+    lat: 0, lon: 0, gLat: 0, gLon: 0, gdLat: 39.9177, gdLon: 116.397,
+};
+
+const HANOI_LANDMARK = {
+    id: '6790582', type: 'Markland', word: '升龙皇城', cityId: 286, cityName: '河内',
+    provinceName: '', countryName: '越南', displayName: '升龙皇城, 河内, 越南',
+    displayType: '地标', eName: 'Imperial Citadel of Thang Long', commentScore: 0,
+    lat: 0, lon: 0, gLat: 21.0352, gLon: 105.8403, gdLat: 0, gdLon: 0,
+};
+
+const HOTEL_ROW = {
+    id: '133133582', type: 'Hotel', word: '汉庭酒店上海陆家嘴店', cityId: 2,
+    cityName: '上海', provinceName: '上海', countryName: '中国',
+    displayName: '汉庭酒店上海陆家嘴店, 上海, 中国', displayType: '酒店',
+    cStar: 4.2, commentScore: 0,
+};
+
+describe('ctrip parseLimit', () => {
+    it('returns fallback for undefined / null / empty', () => {
+        expect(parseLimit(undefined)).toBe(15);
+        expect(parseLimit(null)).toBe(15);
+        expect(parseLimit('')).toBe(15);
+    });
+    it('accepts integers in [1, 50]', () => {
+        expect(parseLimit(1)).toBe(1);
+        expect(parseLimit(50)).toBe(50);
+        expect(parseLimit('25')).toBe(25);
+    });
+    it('rejects non-integer', () => {
+        expect(() => parseLimit('abc')).toThrow('--limit must be an integer');
+        expect(() => parseLimit(3.5)).toThrow('--limit must be an integer');
+    });
+    it('rejects out-of-range without silent clamp', () => {
+        expect(() => parseLimit(0)).toThrow('--limit must be between 1 and 50, got 0');
+        expect(() => parseLimit(51)).toThrow('--limit must be between 1 and 50, got 51');
+        expect(() => parseLimit(-3)).toThrow('--limit must be between 1 and 50');
+    });
+});
+
+describe('ctrip pickCoords', () => {
+    it('prefers gd coords (mainland) when present', () => {
+        expect(pickCoords(SHANGHAI_CITY)).toEqual({ lat: 31.2304, lon: 121.4737 });
+    });
+    it('falls back to g coords (international) when gd is zero', () => {
+        expect(pickCoords(HANOI_LANDMARK)).toEqual({ lat: 21.0352, lon: 105.8403 });
+    });
+    it('returns null/null when all coord variants are zero', () => {
+        expect(pickCoords(HOTEL_ROW)).toEqual({ lat: null, lon: null });
+    });
+});
+
+describe('ctrip buildUrl', () => {
+    it('constructs city URL', () => {
+        expect(buildUrl(SHANGHAI_CITY)).toBe('https://you.ctrip.com/place/%E4%B8%8A%E6%B5%B72.html');
+    });
+    it('constructs landmark URL', () => {
+        expect(buildUrl(FORBIDDEN_CITY)).toBe('https://you.ctrip.com/sight/%E5%8C%97%E4%BA%AC1/4189051.html');
+    });
+    it('constructs hotel URL', () => {
+        expect(buildUrl(HOTEL_ROW)).toBe('https://hotels.ctrip.com/hotels/detail/?hotelid=133133582');
+    });
+    it('returns null for unknown type rather than fabricating', () => {
+        expect(buildUrl({ type: 'WhoKnows', id: '1', cityId: 1, cityName: 'X' })).toBeNull();
+    });
+});
+
+describe('ctrip mapSuggestRow', () => {
+    it('preserves all geo / english / id columns (no silent column drop)', () => {
+        const row = mapSuggestRow(FORBIDDEN_CITY, 0);
+        expect(row).toEqual({
+            rank: 1,
+            id: '4189051',
+            type: 'Markland',
+            displayType: '地标',
+            name: '故宫博物院, 北京, 中国',
+            eName: 'The Palace Museum',
+            cityId: 1,
+            cityName: '北京',
+            provinceName: '北京',
+            countryName: '中国',
+            lat: 39.9177,
+            lon: 116.397,
+            score: 4.8,
+            url: 'https://you.ctrip.com/sight/%E5%8C%97%E4%BA%AC1/4189051.html',
+        });
+    });
+    it('uses cStar as score fallback when commentScore is 0', () => {
+        const row = mapSuggestRow({ ...FORBIDDEN_CITY, commentScore: 0, cStar: 4.5 }, 2);
+        expect(row.score).toBe(4.5);
+    });
+    it('returns null score when both commentScore and cStar are missing/zero', () => {
+        expect(mapSuggestRow(SHANGHAI_CITY, 0).score).toBeNull();
+    });
+});
+
+describe('ctrip search command (registry-level)', () => {
+    const cmd = getRegistry().get('ctrip/search');
+    beforeEach(() => vi.unstubAllGlobals());
+
+    it('declares Strategy.PUBLIC + browser:false + access:read', () => {
+        expect(cmd.access).toBe('read');
+        expect(cmd.browser).toBe(false);
+        expect(String(cmd.strategy)).toContain('public');
+    });
+
+    it('maps live response with full column shape', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0,
+            Response: { searchResults: [SHANGHAI_CITY, FORBIDDEN_CITY] },
+        }))));
+        const rows = await cmd.func({ query: '上海', limit: 5 });
+        expect(rows).toHaveLength(2);
+        expect(rows[0].cityId).toBe(2);
+        expect(rows[0].lat).toBeCloseTo(31.2304);
+        expect(rows[1].url).toContain('/sight/');
+        // shape parity: every row has every declared column key
+        for (const row of rows) {
+            for (const col of cmd.columns) expect(row).toHaveProperty(col);
+        }
+    });
+
+    it('rejects empty query with ArgumentError', async () => {
+        await expect(cmd.func({ query: '   ', limit: 3 })).rejects.toThrow('Search keyword cannot be empty');
+    });
+
+    it('surfaces fetch failures as typed FETCH_ERROR', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(new Response('{}', { status: 503 }))));
+        await expect(cmd.func({ query: '上海', limit: 3 })).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+        });
+    });
+
+    it('wraps network failures as typed FETCH_ERROR', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.reject(new Error('socket hang up'))));
+        await expect(cmd.func({ query: '上海', limit: 3 })).rejects.toMatchObject({
+            code: 'FETCH_ERROR',
+            message: expect.stringContaining('socket hang up'),
+        });
+    });
+
+    it('wraps invalid JSON as typed COMMAND_EXEC', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(new Response('not json', { status: 200 }))));
+        await expect(cmd.func({ query: '上海', limit: 3 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('invalid JSON'),
+        });
+    });
+
+    it('surfaces in-band Result=false as typed COMMAND_EXEC', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: false, ErrorCode: 17,
+        }))));
+        await expect(cmd.func({ query: '上海', limit: 3 })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+        });
+    });
+
+    it('surfaces empty results as EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0, Response: { searchResults: [] },
+        }))));
+        await expect(cmd.func({ query: '上海', limit: 3 })).rejects.toThrow('ctrip search returned no data');
+    });
+
+    it('rejects --limit 0 / 51 with ArgumentError (no silent clamp)', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0, Response: { searchResults: [SHANGHAI_CITY] },
+        }))));
+        await expect(cmd.func({ query: '上海', limit: 0 })).rejects.toThrow('--limit');
+        await expect(cmd.func({ query: '上海', limit: 51 })).rejects.toThrow('--limit');
+    });
+});
+
+describe('ctrip hotel-suggest command (registry-level)', () => {
+    const cmd = getRegistry().get('ctrip/hotel-suggest');
+    beforeEach(() => vi.unstubAllGlobals());
+
+    it('declares Strategy.PUBLIC + browser:false + access:read', () => {
+        expect(cmd.access).toBe('read');
+        expect(cmd.browser).toBe(false);
+        expect(String(cmd.strategy)).toContain('public');
+    });
+
+    it('maps Hotel rows with hotel detail URL', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0,
+            Response: { searchResults: [SHANGHAI_CITY, HOTEL_ROW] },
+        }))));
+        const rows = await cmd.func({ query: '汉庭', limit: 5 });
+        expect(rows).toHaveLength(2);
+        const hotel = rows.find((r) => r.type === 'Hotel');
+        expect(hotel.url).toBe('https://hotels.ctrip.com/hotels/detail/?hotelid=133133582');
+    });
+
+    it('passes searchType=H to the upstream endpoint', async () => {
+        const fetchMock = vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0,
+            Response: { searchResults: [HOTEL_ROW] },
+        })));
+        vi.stubGlobal('fetch', fetchMock);
+        await cmd.func({ query: '汉庭', limit: 5 });
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body.searchType).toBe('H');
+    });
+
+    it('surfaces empty hotel-context lookup as EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn(() => Promise.resolve(ok({
+            Result: true, ErrorCode: 0, Response: { searchResults: [] },
+        }))));
+        await expect(cmd.func({ query: 'zzz', limit: 5 })).rejects.toThrow('ctrip hotel-suggest returned no data');
+    });
+});

package/clis/ctrip/hotel-suggest.js

@@ -0,0 +1,45 @@
+/**
+ * 携程酒店 hotel-context suggest — public city/business-area/hotel lookup.
+ *
+ * Distinct from `ctrip/search` (destination): the same backing endpoint is
+ * called with `searchType=H`, surfacing Hotel and BusinessArea rows that the
+ * destination flavour does not return.
+ */
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { fetchSuggest, mapSuggestRow, parseLimit } from './utils.js';
+
+cli({
+    site: 'ctrip',
+    name: 'hotel-suggest',
+    access: 'read',
+    description: '搜索携程酒店上下文联想：城市、商圈、单酒店匹配',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'query', required: true, positional: true, help: 'Search keyword (city, business area, or hotel name)' },
+        { name: 'limit', type: 'int', default: 15, help: 'Number of results (1-50)' },
+    ],
+    columns: [
+        'rank', 'id', 'type', 'displayType', 'name', 'eName',
+        'cityId', 'cityName', 'provinceName', 'countryName',
+        'lat', 'lon', 'score', 'url',
+    ],
+    func: async (kwargs) => {
+        const query = String(kwargs.query || '').trim();
+        if (!query) {
+            throw new ArgumentError('Search keyword cannot be empty');
+        }
+        const limit = parseLimit(kwargs.limit);
+        const raw = await fetchSuggest(query, 'H');
+        const rows = raw
+            .filter((item) => !!item && typeof item === 'object')
+            .slice(0, limit)
+            .map(mapSuggestRow)
+            .filter((row) => row.name);
+        if (!rows.length) {
+            throw new EmptyResultError('ctrip hotel-suggest', 'Try a city, business area, or hotel keyword such as "陆家嘴" or "汉庭酒店"');
+        }
+        return rows;
+    },
+});

package/clis/ctrip/search.js

@@ -1,87 +1,41 @@
 /**
- * 携程旅行搜索 — public destination and hotel suggestion lookup.
+ * 携程旅行 destination suggest — public city/landmark/scenic-spot lookup.
  */
-import { ArgumentError, CliError, EmptyResultError } from '@jackwener/opencli/errors';
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-function clampLimit(raw, fallback = 15) {
-    const parsed = Number(raw);
-    if (!Number.isFinite(parsed))
-        return fallback;
-    return Math.max(1, Math.min(Math.floor(parsed), 50));
-}
-function mapSearchResults(results, limit) {
-    return results
-        .filter((item) => !!item && typeof item === 'object')
-        .slice(0, limit)
-        .map((item, index) => ({
-        rank: index + 1,
-        name: String(item.displayName || item.word || item.cityName || '').replace(/\s+/g, ' ').trim(),
-        type: String(item.displayType || item.type || '').replace(/\s+/g, ' ').trim(),
-        score: item.commentScore ?? item.cStar ?? '',
-        price: item.price ?? item.minPrice ?? '',
-        url: '',
-    }))
-        .filter((item) => item.name);
-}
+import { fetchSuggest, mapSuggestRow, parseLimit } from './utils.js';
+
 cli({
     site: 'ctrip',
     name: 'search',
     access: 'read',
-    description: '搜索携程目的地、景区和酒店联想结果',
+    description: '搜索携程目的地、景区、火车站和地标联想结果',
     strategy: Strategy.PUBLIC,
     browser: false,
     args: [
-        { name: 'query', required: true, positional: true, help: 'Search keyword (city or attraction)' },
-        { name: 'limit', type: 'int', default: 15, help: 'Number of results' },
+        { name: 'query', required: true, positional: true, help: 'Search keyword (city, scenic spot, landmark)' },
+        { name: 'limit', type: 'int', default: 15, help: 'Number of results (1-50)' },
+    ],
+    columns: [
+        'rank', 'id', 'type', 'displayType', 'name', 'eName',
+        'cityId', 'cityName', 'provinceName', 'countryName',
+        'lat', 'lon', 'score', 'url',
     ],
-    columns: ['rank', 'name', 'type', 'score', 'price', 'url'],
     func: async (kwargs) => {
         const query = String(kwargs.query || '').trim();
         if (!query) {
             throw new ArgumentError('Search keyword cannot be empty');
         }
-        const limit = clampLimit(kwargs.limit);
-        const response = await fetch('https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine', {
-            method: 'POST',
-            headers: {
-                'content-type': 'application/json',
-            },
-            body: JSON.stringify({
-                keyword: query,
-                searchType: 'D',
-                platform: 'online',
-                pageID: '102001',
-                head: {
-                    Locale: 'zh-CN',
-                    LocaleController: 'zh_cn',
-                    Currency: 'CNY',
-                    PageId: '102001',
-                    clientID: 'opencli-ctrip-search',
-                    group: 'ctrip',
-                    Frontend: {
-                        sessionID: 1,
-                        pvid: 1,
-                    },
-                    HotelExtension: {
-                        group: 'CTRIP',
-                        WebpSupport: false,
-                    },
-                },
-            }),
-        });
-        if (!response.ok) {
-            throw new CliError('FETCH_ERROR', `ctrip search failed with status ${response.status}`, 'Retry the command or verify ctrip.com is reachable');
-        }
-        const payload = await response.json();
-        const rawResults = Array.isArray(payload?.Response?.searchResults) ? payload.Response.searchResults : [];
-        const results = mapSearchResults(rawResults, limit);
-        if (!results.length) {
-            throw new EmptyResultError('ctrip search', 'Try a destination, scenic spot, or hotel keyword such as "苏州" or "朱家尖"');
+        const limit = parseLimit(kwargs.limit);
+        const raw = await fetchSuggest(query, 'D');
+        const rows = raw
+            .filter((item) => !!item && typeof item === 'object')
+            .slice(0, limit)
+            .map(mapSuggestRow)
+            .filter((row) => row.name);
+        if (!rows.length) {
+            throw new EmptyResultError('ctrip search', 'Try a destination, scenic spot, or landmark keyword such as "苏州" or "故宫"');
         }
-        return results;
+        return rows;
     },
 });
-export const __test__ = {
-    clampLimit,
-    mapSearchResults,
-};