@jackwener/opencli 1.6.2 → 1.6.3

package/src/clis/coupang/utils.ts

@@ -1,302 +0,0 @@
-export interface CoupangSearchItem {
-  rank: number;
-  product_id: string;
-  title: string;
-  price: number | null;
-  original_price: number | null;
-  unit_price: string;
-  discount_rate: number | null;
-  rating: number | null;
-  review_count: number | null;
-  rocket: string;
-  delivery_type: string;
-  delivery_promise: string;
-  seller: string;
-  badge: string;
-  category: string;
-  url: string;
-}
-
-function itemKey(item: CoupangSearchItem): string {
-  return item.url || item.product_id || `${item.title}:${item.price ?? ''}`;
-}
-
-const ROCKET_PATTERNS = ['판매자로켓', '로켓프레시', '로켓와우', '로켓배송', '로켓직구'] as const;
-const DELIVERY_TYPE_PATTERNS = ['무료배송', '일반배송'] as const;
-const DELIVERY_PROMISE_PATTERNS = ['오늘도착', '내일도착', '새벽도착', '오늘출발'] as const;
-
-const BADGE_ID_TO_ROCKET: Record<string, string> = {
-  ROCKET: '로켓배송',
-  ROCKET_MERCHANT: '판매자로켓',
-  ROCKET_WOW: '로켓와우',
-  WOW: '로켓와우',
-  ROCKET_FRESH: '로켓프레시',
-  FRESH: '로켓프레시',
-  SELLER_ROCKET: '판매자로켓',
-  ROCKET_JIKGU: '로켓직구',
-  JIKGU: '로켓직구',
-  COUPANG_GLOBAL: '로켓직구',
-};
-
-const BADGE_ID_TO_PROMISE: Record<string, string> = {
-  DAWN: '새벽도착',
-  EARLY_DAWN: '새벽도착',
-  TOMORROW: '내일도착',
-  TODAY: '오늘도착',
-  SAME_DAY: '오늘도착',
-  TODAY_SHIP: '오늘출발',
-  TODAY_DISPATCH: '오늘출발',
-};
-
-function asString(value: unknown): string {
-  if (value == null) return '';
-  return String(value).trim();
-}
-
-function toNumber(value: unknown): number | null {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  const text = asString(value).replace(/[^\d.]/g, '');
-  if (!text) return null;
-  const num = Number(text);
-  return Number.isFinite(num) ? num : null;
-}
-
-function pickFirst(obj: Record<string, unknown>, paths: string[]): unknown {
-  for (const path of paths) {
-    const parts = path.split('.');
-    let current: unknown = obj;
-    let ok = true;
-    for (const part of parts) {
-      if (!current || typeof current !== 'object' || !(part in (current as Record<string, unknown>))) {
-        ok = false;
-        break;
-      }
-      current = (current as Record<string, unknown>)[part];
-    }
-    if (ok && current != null && asString(current) !== '') return current;
-  }
-  return null;
-}
-
-export function normalizeProductId(raw: unknown): string {
-  const text = asString(raw);
-  if (!text) return '';
-  const match = text.match(/\/vp\/products\/(\d+)/) || text.match(/\b(\d{6,})\b/);
-  return match?.[1] ?? text;
-}
-
-export function canonicalizeProductUrl(rawUrl: unknown, productId?: unknown): string {
-  const raw = asString(rawUrl);
-  if (raw) {
-    try {
-      const url = new URL(raw.startsWith('http') ? raw : `https://www.coupang.com${raw}`);
-      if (!url.hostname.includes('coupang.com')) return '';
-      const id = normalizeProductId(url.pathname) || normalizeProductId(productId);
-      if (!id) return url.toString();
-      return `https://www.coupang.com/vp/products/${id}`;
-    } catch {
-      return '';
-    }
-  }
-
-  const id = normalizeProductId(productId);
-  return id ? `https://www.coupang.com/vp/products/${id}` : '';
-}
-
-function extractTokens(values: unknown[]): string[] {
-  return values
-    .flatMap((value) => {
-      const text = asString(value);
-      if (!text) return [];
-      return text.split(/[,\s|]+/);
-    })
-    .map((token) => token.trim().toUpperCase())
-    .filter(Boolean);
-}
-
-function normalizeJoinedText(...values: unknown[]): string {
-  return values
-    .map(asString)
-    .filter(Boolean)
-    .join(' ')
-    .replace(/schema\.org\/[A-Za-z]+/gi, ' ')
-    .replace(/\s+/g, ' ')
-    .trim();
-}
-
-function normalizeRocket(...values: unknown[]): string {
-  const tokens = extractTokens(values);
-  for (const token of tokens) {
-    if (BADGE_ID_TO_ROCKET[token]) return BADGE_ID_TO_ROCKET[token];
-  }
-  const text = normalizeJoinedText(...values);
-  if (!text) return '';
-  if (/판매자\s*로켓/.test(text)) return '판매자로켓';
-  if (/로켓\s*프레시|새벽\s*도착\s*보장/.test(text)) return '로켓프레시';
-  if (/로켓\s*와우/.test(text)) return '로켓와우';
-  if (/로켓\s*직구|직구/.test(text)) return '로켓직구';
-  if (/로켓\s*배송/.test(text)) return '로켓배송';
-  return ROCKET_PATTERNS.find(pattern => text.includes(pattern)) ?? '';
-}
-
-function normalizeDeliveryType(...values: unknown[]): string {
-  const text = normalizeJoinedText(...values);
-  if (!text) return '';
-  if (/무료\s*배송/.test(text)) return '무료배송';
-  if (/일반\s*배송/.test(text)) return '일반배송';
-  return DELIVERY_TYPE_PATTERNS.find(pattern => text.includes(pattern)) ?? '';
-}
-
-function normalizeDeliveryPromise(...values: unknown[]): string {
-  const tokens = extractTokens(values);
-  for (const token of tokens) {
-    if (BADGE_ID_TO_PROMISE[token]) return BADGE_ID_TO_PROMISE[token];
-  }
-  const text = normalizeJoinedText(...values);
-  if (!text) return '';
-  if (/오늘\s*출발/.test(text)) return '오늘출발';
-  if (/오늘.*도착/.test(text)) return '오늘도착';
-  if (/새벽.*도착/.test(text)) return '새벽도착';
-  if (/내일.*도착/.test(text)) return '내일도착';
-  return DELIVERY_PROMISE_PATTERNS.find(pattern => text.includes(pattern)) ?? '';
-}
-
-function normalizeBadge(value: unknown): string {
-  const normalizeOne = (entry: unknown): string => {
-    const text = asString(entry);
-    if (!text) return '';
-    if (/schema\.org\//i.test(text)) {
-      return text.split('/').pop() ?? '';
-    }
-    return text;
-  };
-  if (Array.isArray(value)) {
-    return value.map(normalizeOne).filter(Boolean).join(', ');
-  }
-  return normalizeOne(value);
-}
-
-export function normalizeSearchItem(raw: Record<string, unknown>, index: number): CoupangSearchItem {
-  const productId = normalizeProductId(
-    pickFirst(raw, ['productId', 'product_id', 'id', 'productNo', 'item.id', 'product.productId', 'url'])
-  );
-  const title = asString(
-    pickFirst(raw, ['title', 'name', 'productName', 'productTitle', 'itemName', 'item.title'])
-  );
-  const price = toNumber(
-    pickFirst(raw, ['price', 'salePrice', 'finalPrice', 'sellingPrice', 'discountPrice', 'item.price'])
-  );
-  const originalPrice = toNumber(
-    pickFirst(raw, ['originalPrice', 'basePrice', 'listPrice', 'originPrice', 'strikePrice'])
-  );
-  const unitPrice = asString(
-    pickFirst(raw, ['unitPrice', 'unit_price', 'unitPriceText'])
-  );
-  const rating = toNumber(
-    pickFirst(raw, ['rating', 'star', 'reviewRating', 'review.rating', 'item.rating'])
-  );
-  const reviewCount = toNumber(
-    pickFirst(raw, ['reviewCount', 'ratingCount', 'reviews', 'reviewCnt', 'item.reviewCount'])
-  );
-  const deliveryHintValues = [
-    pickFirst(raw, ['deliveryType', 'deliveryBadge', 'badgeLabel', 'shippingType', 'shippingBadge']),
-    pickFirst(raw, ['badge', 'badges', 'labels', 'benefitBadge', 'promotionBadge']),
-    pickFirst(raw, ['text', 'summary']),
-    pickFirst(raw, ['deliveryPromise', 'promise', 'arrivalText', 'arrivalBadge']),
-    pickFirst(raw, ['rocket', 'rocketType']),
-  ];
-  const deliveryType = normalizeDeliveryType(...deliveryHintValues);
-  const deliveryPromise = normalizeDeliveryPromise(...deliveryHintValues);
-  const rocket = normalizeRocket(...deliveryHintValues);
-  const badge = normalizeBadge(
-    pickFirst(raw, ['badge', 'badges', 'labels', 'benefitBadge', 'promotionBadge'])
-  );
-  const category = asString(
-    pickFirst(raw, ['category', 'categoryName', 'categoryPath', 'item.category'])
-  );
-  const seller = asString(
-    pickFirst(raw, ['seller', 'sellerName', 'vendorName', 'merchantName', 'item.seller'])
-  );
-  const url = canonicalizeProductUrl(
-    pickFirst(raw, ['url', 'productUrl', 'link', 'item.url']),
-    productId
-  );
-  const discountRate = toNumber(
-    pickFirst(raw, ['discountRate', 'discount', 'discountPercent', 'discount_rate'])
-  );
-
-  return {
-    rank: index + 1,
-    product_id: productId,
-    title,
-    price,
-    original_price: originalPrice,
-    unit_price: unitPrice,
-    discount_rate: discountRate,
-    rating,
-    review_count: reviewCount,
-    rocket,
-    delivery_type: deliveryType,
-    delivery_promise: deliveryPromise,
-    seller,
-    badge,
-    category,
-    url,
-  };
-}
-
-export function dedupeSearchItems(items: CoupangSearchItem[]): CoupangSearchItem[] {
-  const seen = new Set<string>();
-  const out: CoupangSearchItem[] = [];
-  for (const item of items) {
-    const key = itemKey(item);
-    if (!key || seen.has(key)) continue;
-    seen.add(key);
-    out.push({ ...item, rank: out.length + 1 });
-  }
-  return out;
-}
-
-export function sanitizeSearchItems(items: CoupangSearchItem[], limit: number): CoupangSearchItem[] {
-  return dedupeSearchItems(
-    items.filter(item => Boolean(item.title && (item.product_id || item.url)))
-  ).slice(0, limit);
-}
-
-export function mergeSearchItems(base: CoupangSearchItem[], extra: CoupangSearchItem[], limit: number): CoupangSearchItem[] {
-  const extraMap = new Map<string, CoupangSearchItem>();
-  for (const item of extra) {
-    const key = itemKey(item);
-    if (key) extraMap.set(key, item);
-  }
-
-  const merged = base.map((item) => {
-    const key = itemKey(item);
-    const patch = key ? extraMap.get(key) : null;
-    if (!patch) return item;
-    return {
-      ...item,
-      price: patch.price ?? item.price,
-      original_price: patch.original_price ?? item.original_price,
-      unit_price: patch.unit_price || item.unit_price,
-      discount_rate: patch.discount_rate ?? item.discount_rate,
-      rating: patch.rating ?? item.rating,
-      review_count: patch.review_count ?? item.review_count,
-      rocket: patch.rocket || item.rocket,
-      delivery_type: patch.delivery_type || item.delivery_type,
-      delivery_promise: patch.delivery_promise || item.delivery_promise,
-      seller: patch.seller || item.seller,
-      badge: patch.badge || item.badge,
-      category: patch.category || item.category,
-      url: patch.url || item.url,
-    };
-  });
-
-  const mergedKeys = new Set(merged.map(item => itemKey(item)).filter(Boolean));
-  const appended = extra.filter(item => {
-    const key = itemKey(item);
-    return key && !mergedKeys.has(key);
-  });
-
-  return sanitizeSearchItems([...merged, ...appended], limit);
-}

package/src/clis/ctrip/search.test.ts

@@ -1,73 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '../../registry.js';
-import './search.js';
-
-describe('ctrip search', () => {
-  const command = getRegistry().get('ctrip/search');
-
-  beforeEach(() => {
-    vi.unstubAllGlobals();
-  });
-
-  it('maps live endpoint results into ranked rows', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
-      Response: {
-        searchResults: [
-          {
-            displayName: '苏州, 江苏, 中国',
-            displayType: '城市',
-            commentScore: 0,
-            price: '',
-          },
-          {
-            word: '姑苏区',
-            type: '行政区',
-            cStar: 4.8,
-            minPrice: 320,
-          },
-        ],
-      },
-    }), { status: 200 })));
-
-    const result = await command!.func!(null as any, { query: '苏州', limit: 3 });
-    expect(result).toEqual([
-      {
-        rank: 1,
-        name: '苏州, 江苏, 中国',
-        type: '城市',
-        score: 0,
-        price: '',
-        url: '',
-      },
-      {
-        rank: 2,
-        name: '姑苏区',
-        type: '行政区',
-        score: 4.8,
-        price: 320,
-        url: '',
-      },
-    ]);
-  });
-
-  it('rejects empty queries', async () => {
-    await expect(command!.func!(null as any, { query: '   ', limit: 3 })).rejects.toThrow('Search keyword cannot be empty');
-  });
-
-  it('surfaces fetch failures as CliError', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('{}', { status: 503 })));
-
-    await expect(command!.func!(null as any, { query: '苏州', limit: 3 })).rejects.toMatchObject({
-      code: 'FETCH_ERROR',
-      message: 'ctrip search failed with status 503',
-    });
-  });
-
-  it('surfaces empty results as EmptyResultError', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({
-      Response: { searchResults: [] },
-    }), { status: 200 })));
-
-    await expect(command!.func!(null as any, { query: '苏州', limit: 3 })).rejects.toThrow('ctrip search returned no data');
-  });
-});

package/src/clis/ctrip/search.ts

@@ -1,111 +0,0 @@
-/**
- * 携程旅行搜索 — public destination and hotel suggestion lookup.
- */
-import { ArgumentError, CliError, EmptyResultError } from '../../errors.js';
-import { cli, Strategy } from '../../registry.js';
-
-interface CtripSearchResultItem {
-  displayName?: string;
-  word?: string;
-  cityName?: string;
-  displayType?: string;
-  type?: string;
-  commentScore?: number | string;
-  cStar?: number | string;
-  price?: number | string;
-  minPrice?: number | string;
-}
-
-function clampLimit(raw: unknown, fallback = 15): number {
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(1, Math.min(Math.floor(parsed), 50));
-}
-
-function mapSearchResults(results: unknown[], limit: number) {
-  return results
-    .filter((item): item is CtripSearchResultItem => !!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);
-}
-
-cli({
-  site: 'ctrip',
-  name: 'search',
-  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' },
-  ],
-  columns: ['rank', 'name', 'type', 'score', 'price', 'url'],
-  func: async (_page, 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 "朱家尖"',
-      );
-    }
-    return results;
-  },
-});
-
-export const __test__ = {
-  clampLimit,
-  mapSearchResults,
-};

package/src/clis/cursor/ask.ts

@@ -1,82 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { SelectorError } from '../../errors.js';
-import type { IPage } from '../../types.js';
-
-export const askCommand = cli({
-  site: 'cursor',
-  name: 'ask',
-  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', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
-  ],
-  columns: ['Role', 'Text'],
-  func: async (page: IPage, kwargs: any) => {
-    const text = kwargs.text as string;
-    const timeout = parseInt(kwargs.timeout as string, 10) || 30;
-
-    // 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 new 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/src/clis/cursor/composer.ts

@@ -1,51 +0,0 @@
-import { cli, Strategy } from '../../registry.js';
-import { SelectorError } from '../../errors.js';
-import type { IPage } from '../../types.js';
-
-export const composerCommand = cli({
-  site: 'cursor',
-  name: 'composer',
-  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: IPage, kwargs: any) => {
-    const textToInsert = kwargs.text as string;
-
-    // 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 new 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/src/clis/cursor/dump.ts

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

package/src/clis/cursor/export.ts

@@ -1,57 +0,0 @@
-import * as fs from 'node:fs';
-import { cli, Strategy } from '../../registry.js';
-import type { IPage } from '../../types.js';
-
-function makeExportCommand(site: string, readSelector: string) {
-  return cli({
-    site,
-    name: 'export',
-    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: IPage, kwargs: any) => {
-      const outputPath = (kwargs.output as string) || `/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]');