publishport-opencli 1.8.4-pp.1

package/clis/ctrip/utils.js

@@ -0,0 +1,473 @@
+/**
+ * Shared helpers for ctrip public destination/hotel suggestion endpoints.
+ *
+ * The single backing endpoint `https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine`
+ * accepts a `searchType` discriminator:
+ *   - `D` → destination suggest (cities, scenic spots, railway stations, landmarks)
+ *   - `H` → hotel-context suggest (cities, business areas, individual hotels)
+ *
+ * Response shape is identical; we surface every field the endpoint emits as a
+ * stable column so callers do not silently lose geo / English / id metadata.
+ */
+import { ArgumentError, CliError } from '@jackwener/opencli/errors';
+
+const ENDPOINT = 'https://m.ctrip.com/restapi/soa2/21881/json/gaHotelSearchEngine';
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 50;
+
+export function parseLimit(raw, fallback = 15) {
+    if (raw === undefined || raw === null || raw === '') return fallback;
+    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;
+}
+
+export async function fetchSuggest(query, searchType) {
+    let response;
+    try {
+        response = await fetch(ENDPOINT, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+                keyword: query,
+                searchType,
+                platform: 'online',
+                pageID: '102001',
+                head: {
+                    Locale: 'zh-CN',
+                    LocaleController: 'zh_cn',
+                    Currency: 'CNY',
+                    PageId: '102001',
+                    clientID: 'opencli-ctrip',
+                    group: 'ctrip',
+                    Frontend: { sessionID: 1, pvid: 1 },
+                    HotelExtension: { group: 'CTRIP', WebpSupport: false },
+                },
+            }),
+        });
+    } catch (err) {
+        throw new CliError(
+            'FETCH_ERROR',
+            `ctrip suggest fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+            'Check your network connection and retry',
+        );
+    }
+    if (!response.ok) {
+        throw new CliError(
+            'FETCH_ERROR',
+            `ctrip suggest failed with status ${response.status}`,
+            'Retry the command or verify ctrip.com is reachable',
+        );
+    }
+    let payload;
+    try {
+        payload = await response.json();
+    } catch (err) {
+        throw new CliError(
+            'COMMAND_EXEC',
+            `ctrip suggest returned invalid JSON: ${err instanceof Error ? err.message : String(err)}`,
+            'Ctrip may have changed the endpoint response format; retry later',
+        );
+    }
+    if (payload && payload.Result === false) {
+        const code = payload.ErrorCode ?? 'unknown';
+        throw new CliError(
+            'COMMAND_EXEC',
+            `ctrip suggest API returned Result=false (ErrorCode=${code})`,
+            'Verify keyword and retry; this typically means upstream rejected the query envelope',
+        );
+    }
+    return Array.isArray(payload?.Response?.searchResults) ? payload.Response.searchResults : [];
+}
+
+/**
+ * Pick the best lat/lon pair available.
+ *
+ * Domestic Mainland China rows ship `gdLat`/`gdLon` (gaode); international rows
+ * ship `gLat`/`gLon` (google/wgs84). `lat`/`lon` is the legacy flat field — fall
+ * through to it last. Zero values are treated as "missing" since the endpoint
+ * uses 0.0 as a sentinel for unknown coords.
+ */
+export function pickCoords(item) {
+    const candidates = [
+        [item.gdLat, item.gdLon],
+        [item.gLat, item.gLon],
+        [item.lat, item.lon],
+    ];
+    for (const [la, lo] of candidates) {
+        if (Number.isFinite(la) && Number.isFinite(lo) && (la !== 0 || lo !== 0)) {
+            return { lat: la, lon: lo };
+        }
+    }
+    return { lat: null, lon: null };
+}
+
+/**
+ * Build a canonical user-facing URL from the suggest item type + ids.
+ * Unknown types return null (do not silently fabricate URLs).
+ */
+export function buildUrl(item) {
+    const id = item?.id ? String(item.id) : '';
+    const cityId = item?.cityId ?? '';
+    const cityName = item?.cityName ? String(item.cityName) : '';
+    switch (item?.type) {
+        case 'City':
+            return cityId ? `https://you.ctrip.com/place/${encodeURIComponent(cityName)}${cityId}.html` : null;
+        case 'Markland':
+            return id && cityId
+                ? `https://you.ctrip.com/sight/${encodeURIComponent(cityName)}${cityId}/${id}.html`
+                : null;
+        case 'Hotel':
+            return id ? `https://hotels.ctrip.com/hotels/detail/?hotelid=${id}` : null;
+        case 'BusinessArea':
+        case 'Zone':
+            return cityId && id
+                ? `https://hotels.ctrip.com/hotels/list?city=${cityId}&zone=${id}`
+                : null;
+        case 'RailwayStation':
+            return id ? `https://trains.ctrip.com/trainstation/${id}.html` : null;
+        default:
+            return null;
+    }
+}
+
+function nz(v) {
+    return Number.isFinite(v) && v !== 0 ? v : null;
+}
+
+function firstNonZero(...values) {
+    for (const v of values) {
+        const n = Number(v);
+        if (Number.isFinite(n) && n !== 0) return n;
+    }
+    return null;
+}
+
+/**
+ * Project a raw suggest row into the stable adapter column shape.
+ * No silent fallbacks: every column has a deterministic value (string|number|null).
+ */
+export function mapSuggestRow(item, index) {
+    const { lat, lon } = pickCoords(item);
+    return {
+        rank: index + 1,
+        id: item?.id ? String(item.id) : null,
+        type: item?.type ? String(item.type) : null,
+        displayType: item?.displayType ? String(item.displayType).trim() : null,
+        name: String(item?.displayName || item?.word || item?.cityName || '').replace(/\s+/g, ' ').trim() || null,
+        eName: item?.eName ? String(item.eName).trim() : null,
+        cityId: Number.isFinite(item?.cityId) && item.cityId !== 0 ? item.cityId : null,
+        cityName: item?.cityName ? String(item.cityName).trim() : null,
+        provinceName: item?.provinceName ? String(item.provinceName).trim() : null,
+        countryName: item?.countryName ? String(item.countryName).trim() : null,
+        lat,
+        lon,
+        score: firstNonZero(item?.commentScore, item?.cStar),
+        url: buildUrl(item),
+    };
+}
+
+/* --------- 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/cursor/ask.js

@@ -0,0 +1,74 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, selectorError } from '@jackwener/opencli/errors';
+export const askCommand = cli({
+    site: 'cursor',
+    name: 'ask',
+    access: 'write',
+    description: 'Send a prompt and wait for the AI response (send + wait + read)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for response (default: 30)', default: 30 },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
+        // Count existing messages before sending
+        const beforeCount = await page.evaluate(`
+      document.querySelectorAll('[data-message-role]').length
+    `);
+        // Inject text into the active editor and submit
+        const injected = await page.evaluate(`(function(text) {
+        let editor = document.querySelector('.aislash-editor-input, [data-lexical-editor="true"], [contenteditable="true"]');
+        if (!editor) return false;
+        editor.focus();
+        document.execCommand('insertText', false, text);
+        return true;
+      })(${JSON.stringify(text)})`);
+        if (!injected)
+            throw selectorError('Cursor input element');
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        // Poll until a new assistant message appears or timeout
+        const pollInterval = 2; // seconds
+        const maxPolls = Math.ceil(timeout / pollInterval);
+        let response = '';
+        for (let i = 0; i < maxPolls; i++) {
+            await page.wait(pollInterval);
+            const result = await page.evaluate(`
+        (function(prevCount) {
+          const msgs = document.querySelectorAll('[data-message-role]');
+          if (msgs.length <= prevCount) return null;
+          
+          const lastMsg = msgs[msgs.length - 1];
+          const role = lastMsg.getAttribute('data-message-role');
+          if (role === 'human') return null; // Still waiting for assistant
+          
+          const root = lastMsg.querySelector('.markdown-root');
+          const text = root ? root.innerText : lastMsg.innerText;
+          return text ? text.trim() : null;
+        })(${beforeCount})
+      `);
+            if (result) {
+                response = result;
+                break;
+            }
+        }
+        if (!response) {
+            return [
+                { Role: 'User', Text: text },
+                { Role: 'System', Text: `No response received within ${timeout}s. The AI may still be generating.` },
+            ];
+        }
+        return [
+            { Role: 'User', Text: text },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});

package/clis/cursor/composer.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { selectorError } from '@jackwener/opencli/errors';
+export const composerCommand = cli({
+    site: 'cursor',
+    name: 'composer',
+    access: 'write',
+    description: 'Send a prompt directly into Cursor Composer (Cmd+I shortcut)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'text', required: true, positional: true, help: 'Text to send into Composer' }],
+    columns: ['Status', 'InjectedText'],
+    func: async (page, kwargs) => {
+        const textToInsert = kwargs.text;
+        // Open/Focus Composer via shortcut — always works regardless of current state
+        await page.pressKey('Meta+I');
+        await page.wait(1);
+        const typed = await page.evaluate(`(function(text) {
+        let composer = document.activeElement;
+        if (!composer || !composer.isContentEditable) {
+            composer = document.querySelector('.composer-bar [data-lexical-editor="true"], [id*="composer"] [contenteditable="true"], .aislash-editor-input');
+        }
+        
+        if (!composer) return false;
+
+        composer.focus();
+        document.execCommand('insertText', false, text);
+        return true;
+      })(${JSON.stringify(textToInsert)})`);
+        if (!typed) {
+            throw selectorError('Cursor Composer input element', 'Could not find Cursor Composer input element after pressing Cmd+I.');
+        }
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        await page.wait(1);
+        return [
+            {
+                Status: 'Success',
+                InjectedText: textToInsert,
+            },
+        ];
+    },
+});

package/clis/cursor/dump.js

@@ -0,0 +1,2 @@
+import { makeDumpCommand } from '../_shared/desktop-commands.js';
+export const dumpCommand = makeDumpCommand('cursor');

package/clis/cursor/export.js

@@ -0,0 +1,52 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+function makeExportCommand(site, readSelector) {
+    return cli({
+        site,
+        name: 'export',
+    access: 'read',
+        description: `Export the current ${site} conversation to a Markdown file`,
+        domain: 'localhost',
+        strategy: Strategy.UI,
+        browser: true,
+        args: [
+            { name: 'output', required: false, help: `Output file (default: /tmp/${site}-export.md)` },
+        ],
+        columns: ['Status', 'File', 'Messages'],
+        func: async (page, kwargs) => {
+            const outputPath = kwargs.output || `/tmp/${site}-export.md`;
+            const md = await page.evaluate(`
+        (function() {
+          const selectors = ${JSON.stringify(readSelector)}.split(',');
+          let messages = [];
+          
+          for (const sel of selectors) {
+            const nodes = document.querySelectorAll(sel.trim());
+            if (nodes.length > 0) {
+              messages = Array.from(nodes).map(n => n.innerText || n.textContent);
+              break;
+            }
+          }
+
+          if (messages.length === 0) {
+            const main = document.querySelector('main, [role="main"], .messages-list, [role="log"]');
+            if (main) messages = [main.innerText || main.textContent];
+          }
+
+          if (messages.length === 0) messages = [document.body.innerText];
+          
+          return messages.map((m, i) => '## Message ' + (i + 1) + '\\n\\n' + m.trim()).join('\\n\\n---\\n\\n');
+        })()
+      `);
+            fs.writeFileSync(outputPath, `# ${site} Conversation Export\\n\\n` + md);
+            return [
+                {
+                    Status: 'Success',
+                    File: outputPath,
+                    Messages: md.split('## Message').length - 1,
+                },
+            ];
+        },
+    });
+}
+export const cursorExport = makeExportCommand('cursor', '[data-message-role]');

package/clis/cursor/extract-code.js

@@ -0,0 +1,36 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+export const extractCodeCommand = cli({
+    site: 'cursor',
+    name: 'extract-code',
+    access: 'read',
+    description: 'Extract multi-line code blocks from the current Cursor conversation',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Code'],
+    func: async (page) => {
+        const blocks = await page.evaluate(`
+      (function() {
+        // Find standard pre/code blocks
+        let elements = Array.from(document.querySelectorAll('pre code, .markdown-root pre'));
+        
+        // Fallback to Monaco editor content inside the UI
+        if (elements.length === 0) {
+          elements = Array.from(document.querySelectorAll('.monaco-editor'));
+        }
+        
+        // Generic fallback to any code tag that spans multiple lines
+        if (elements.length === 0) {
+          elements = Array.from(document.querySelectorAll('code')).filter(c => c.innerText.includes('\\n'));
+        }
+        
+        return elements.map(el => el.innerText || el.textContent || '').filter(text => text.trim().length > 0);
+      })()
+    `);
+        if (!blocks || blocks.length === 0) {
+            return [{ Code: 'No code blocks found in Cursor.' }];
+        }
+        return blocks.map((code) => ({ Code: code }));
+    },
+});