@jackwener/opencli 1.7.3 → 1.7.4

package/clis/grok/image.ts

@@ -0,0 +1,356 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import type { IPage } from '@jackwener/opencli/types';
+
+const GROK_URL = 'https://grok.com/';
+const NO_IMAGE_PREFIX = '[NO IMAGE]';
+const BLOCKED_PREFIX = '[BLOCKED]';
+const SESSION_HINT = 'Likely login/auth/challenge/session issue in the existing grok.com browser session.';
+
+type SendResult = {
+  ok?: boolean;
+  msg?: string;
+  reason?: string;
+  detail?: string;
+};
+
+type BubbleImage = {
+  src: string;
+  w: number;
+  h: number;
+};
+
+type BubbleImageSet = BubbleImage[];
+
+type FetchResult = {
+  ok: boolean;
+  base64?: string;
+  contentType?: string;
+  error?: string;
+};
+
+function normalizeBooleanFlag(value: unknown): boolean {
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value ?? '').trim().toLowerCase();
+  return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+}
+
+function dedupeBySrc(images: BubbleImage[]): BubbleImage[] {
+  const seen = new Set<string>();
+  const out: BubbleImage[] = [];
+  for (const img of images) {
+    if (!img.src || seen.has(img.src)) continue;
+    seen.add(img.src);
+    out.push(img);
+  }
+  return out;
+}
+
+function imagesSignature(images: BubbleImage[]): string {
+  return images.map(i => i.src).sort().join('|');
+}
+
+function extFromContentType(ct?: string): string {
+  if (!ct) return 'jpg';
+  if (ct.includes('png')) return 'png';
+  if (ct.includes('webp')) return 'webp';
+  if (ct.includes('gif')) return 'gif';
+  return 'jpg';
+}
+
+function buildFilename(src: string, ct?: string): string {
+  const ext = extFromContentType(ct);
+  const hash = crypto.createHash('sha1').update(src).digest('hex').slice(0, 12);
+  return `grok-${Date.now()}-${hash}.${ext}`;
+}
+
+/** Check whether the tab is already on grok.com (any path). */
+async function isOnGrok(page: IPage): Promise<boolean> {
+  const url = await page.evaluate('window.location.href').catch(() => '');
+  if (typeof url !== 'string' || !url) return false;
+  try {
+    const hostname = new URL(url).hostname;
+    return hostname === 'grok.com' || hostname.endsWith('.grok.com');
+  } catch {
+    return false;
+  }
+}
+
+async function tryStartFreshChat(page: IPage): Promise<void> {
+  await page.evaluate(`(() => {
+    const isVisible = (node) => {
+      if (!(node instanceof HTMLElement)) return false;
+      const rect = node.getBoundingClientRect();
+      const style = window.getComputedStyle(node);
+      return rect.width > 0 && rect.height > 0 && style.visibility !== 'hidden' && style.display !== 'none';
+    };
+    const candidates = Array.from(document.querySelectorAll('a, button')).filter(node => {
+      if (!isVisible(node)) return false;
+      const text = (node.textContent || '').trim().toLowerCase();
+      const aria = (node.getAttribute('aria-label') || '').trim().toLowerCase();
+      const href = node.getAttribute('href') || '';
+      return text.includes('new chat')
+        || text.includes('new conversation')
+        || aria.includes('new chat')
+        || aria.includes('new conversation')
+        || href === '/';
+    });
+    const target = candidates[0];
+    if (target instanceof HTMLElement) target.click();
+  })()`);
+}
+
+async function sendPrompt(page: IPage, prompt: string): Promise<SendResult> {
+  const promptJson = JSON.stringify(prompt);
+  return page.evaluate(`(async () => {
+    try {
+      const waitFor = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+      const composerSelector = '.ProseMirror[contenteditable="true"]';
+      const isVisibleEnabledSubmit = (node) => {
+        if (!(node instanceof HTMLButtonElement)) return false;
+        const rect = node.getBoundingClientRect();
+        const style = window.getComputedStyle(node);
+        return !node.disabled
+          && rect.width > 0
+          && rect.height > 0
+          && style.visibility !== 'hidden'
+          && style.display !== 'none';
+      };
+
+      let pm = null;
+      let box = null;
+      for (let attempt = 0; attempt < 12; attempt += 1) {
+        const composer = document.querySelector(composerSelector);
+        if (composer instanceof HTMLElement) {
+          pm = composer;
+          break;
+        }
+
+        const textarea = document.querySelector('textarea');
+        if (textarea instanceof HTMLTextAreaElement) {
+          box = textarea;
+          break;
+        }
+
+        await waitFor(1000);
+      }
+
+      // Prefer the ProseMirror composer when present (current grok.com UI).
+      if (pm && pm.editor && pm.editor.commands) {
+        try {
+          if (pm.editor.commands.clearContent) pm.editor.commands.clearContent();
+          pm.editor.commands.focus();
+          pm.editor.commands.insertContent(${promptJson});
+          for (let attempt = 0; attempt < 6; attempt += 1) {
+            const sbtn = Array.from(document.querySelectorAll('button[aria-label="Submit"], button[aria-label="\\u63d0\\u4ea4"]'))
+              .find(isVisibleEnabledSubmit);
+            if (sbtn) {
+              sbtn.click();
+              return { ok: true, msg: 'pm-submit' };
+            }
+            await waitFor(500);
+          }
+        } catch (e) { /* fall through to textarea */ }
+      }
+
+      // Fallback: legacy textarea composer.
+      if (!box) return { ok: false, msg: 'no composer (neither ProseMirror nor textarea)' };
+      box.focus(); box.value = '';
+      document.execCommand('selectAll');
+      document.execCommand('insertText', false, ${promptJson});
+      for (let attempt = 0; attempt < 6; attempt += 1) {
+        const btn = Array.from(document.querySelectorAll('button[aria-label="\\u63d0\\u4ea4"], button[aria-label="Submit"]'))
+          .find(isVisibleEnabledSubmit);
+        if (btn) {
+          btn.click();
+          return { ok: true, msg: 'clicked' };
+        }
+
+        const sub = Array.from(document.querySelectorAll('button[type="submit"]'))
+          .find(isVisibleEnabledSubmit);
+        if (sub) {
+          sub.click();
+          return { ok: true, msg: 'clicked-submit' };
+        }
+
+        await waitFor(500);
+      }
+      box.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+      return { ok: true, msg: 'enter' };
+    } catch (e) { return { ok: false, msg: e && e.toString ? e.toString() : String(e) }; }
+  })()`) as Promise<SendResult>;
+}
+
+/** Read <img> elements from all message bubbles so callers can filter by baseline. */
+async function getBubbleImageSets(page: IPage): Promise<BubbleImageSet[]> {
+  const result = await page.evaluate(`(() => {
+    const bubbles = document.querySelectorAll('div.message-bubble, [data-testid="message-bubble"]');
+    return Array.from(bubbles).map(bubble => Array.from(bubble.querySelectorAll('img'))
+      .map(img => ({
+        src: img.currentSrc || img.src || '',
+        w: img.naturalWidth || img.width || 0,
+        h: img.naturalHeight || img.height || 0,
+      }))
+      .filter(i => i.src && /^https?:/.test(i.src))
+      // Ignore tiny UI/avatar images that may live in the bubble chrome.
+      .filter(i => (i.w === 0 || i.w >= 128) && (i.h === 0 || i.h >= 128)));
+  })()`) as BubbleImageSet[] | undefined;
+
+  const raw = Array.isArray(result) ? result : [];
+  return raw.map(dedupeBySrc);
+}
+
+function pickLatestImageCandidate(
+  bubbleImageSets: BubbleImageSet[],
+  baselineCount: number,
+): BubbleImage[] {
+  const freshSets = bubbleImageSets.slice(Math.max(0, baselineCount));
+  for (let i = freshSets.length - 1; i >= 0; i -= 1) {
+    if (freshSets[i].length) return freshSets[i];
+  }
+  return [];
+}
+
+// Download through the browser's fetch so grok.com cookies and referer are
+// attached automatically — assets.grok.com is gated by Cloudflare and will
+// refuse direct curl/node downloads.
+async function fetchImageAsBase64(page: IPage, url: string): Promise<FetchResult> {
+  const urlJson = JSON.stringify(url);
+  return page.evaluate(`(async () => {
+    try {
+      const res = await fetch(${urlJson}, { credentials: 'include', referrer: 'https://grok.com/' });
+      if (!res.ok) return { ok: false, error: 'HTTP ' + res.status };
+      const blob = await res.blob();
+      const buf = await blob.arrayBuffer();
+      const bytes = new Uint8Array(buf);
+      let binary = '';
+      for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+      return { ok: true, base64: btoa(binary), contentType: blob.type || 'image/jpeg' };
+    } catch (e) { return { ok: false, error: e && e.message || String(e) }; }
+  })()`) as Promise<FetchResult>;
+}
+
+async function saveImages(
+  page: IPage,
+  images: BubbleImage[],
+  outDir: string,
+): Promise<Array<BubbleImage & { path: string }>> {
+  fs.mkdirSync(outDir, { recursive: true });
+  const results: Array<BubbleImage & { path: string }> = [];
+  for (const img of images) {
+    const fetched = await fetchImageAsBase64(page, img.src);
+    if (!fetched || !fetched.ok) {
+      results.push({ ...img, path: `[DOWNLOAD FAILED] ${fetched?.error || 'unknown'}` });
+      continue;
+    }
+    const filepath = path.join(outDir, buildFilename(img.src, fetched.contentType));
+    fs.writeFileSync(filepath, Buffer.from(fetched.base64 || '', 'base64'));
+    results.push({ ...img, path: filepath });
+  }
+  return results;
+}
+
+function toRow(img: BubbleImage, savedPath = '') {
+  return { url: img.src, width: img.w, height: img.h, path: savedPath };
+}
+
+export const imageCommand = cli({
+  site: 'grok',
+  name: 'image',
+  description: 'Generate images on grok.com and return image URLs',
+  domain: 'grok.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'prompt', positional: true, type: 'string', required: true, help: 'Image generation prompt' },
+    { name: 'timeout', type: 'int', default: 240, help: 'Max seconds to wait for the image (default: 240)' },
+    { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending (default: false)' },
+    { name: 'count', type: 'int', default: 1, help: 'Minimum images to wait for before returning (default: 1)' },
+    { name: 'out', type: 'string', default: '', help: 'Directory to save downloaded images (uses browser session to bypass auth)' },
+  ],
+  columns: ['url', 'width', 'height', 'path'],
+  func: async (page: IPage, kwargs: Record<string, any>) => {
+    const prompt = kwargs.prompt as string;
+    const timeoutMs = ((kwargs.timeout as number) || 240) * 1000;
+    const newChat = normalizeBooleanFlag(kwargs.new);
+    const minCount = Math.max(1, Number(kwargs.count || 1));
+    const outDir = (kwargs.out || '').toString().trim();
+
+    if (newChat) {
+      await page.goto(GROK_URL);
+      await page.wait(2);
+      await tryStartFreshChat(page);
+      await page.wait(2);
+    } else if (!(await isOnGrok(page))) {
+      await page.goto(GROK_URL);
+      await page.wait(3);
+    }
+
+    const baselineBubbleCount = (await getBubbleImageSets(page)).length;
+    const sendResult = await sendPrompt(page, prompt);
+    if (!sendResult || !sendResult.ok) {
+      return [{
+        url: `${BLOCKED_PREFIX} send failed: ${JSON.stringify(sendResult)}. ${SESSION_HINT}`,
+        width: 0,
+        height: 0,
+        path: '',
+      }];
+    }
+
+    const startTime = Date.now();
+    let lastSignature = '';
+    let stableCount = 0;
+    let lastImages: BubbleImage[] = [];
+
+    while (Date.now() - startTime < timeoutMs) {
+      await page.wait(3);
+      const bubbleImageSets = await getBubbleImageSets(page);
+      const images = pickLatestImageCandidate(bubbleImageSets, baselineBubbleCount);
+
+      if (images.length >= minCount) {
+        const signature = imagesSignature(images);
+        if (signature === lastSignature) {
+          stableCount += 1;
+          // Require two consecutive stable reads (~6s) before declaring done.
+          if (stableCount >= 2) {
+            if (outDir) {
+              const saved = await saveImages(page, images, outDir);
+              return saved.map(s => toRow(s, s.path));
+            }
+            return images.map(i => toRow(i));
+          }
+        } else {
+          stableCount = 0;
+          lastSignature = signature;
+          lastImages = images;
+        }
+      }
+    }
+
+    if (lastImages.length) {
+      if (outDir) {
+        const saved = await saveImages(page, lastImages, outDir);
+        return saved.map(s => toRow(s, s.path));
+      }
+      return lastImages.map(i => toRow(i));
+    }
+    return [{
+      url: `${NO_IMAGE_PREFIX} No image appeared within ${Math.round(timeoutMs / 1000)}s.`,
+      width: 0,
+      height: 0,
+      path: '',
+    }];
+  },
+});
+
+export const __test__ = {
+  normalizeBooleanFlag,
+  isOnGrok,
+  dedupeBySrc,
+  imagesSignature,
+  extFromContentType,
+  buildFilename,
+  pickLatestImageCandidate,
+};

package/clis/tdx/hot-rank.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+const TDX_HOT_URL = 'https://pul.tdx.com.cn/site/app/gzhbd/tdx-topsearch/page-main.html?pageName=page_topsearch&tabClickIndex=0&subtabIndex=0';
+
+cli({
+  site: 'tdx',
+  name: 'hot-rank',
+  description: '通达信热搜榜',
+  domain: 'pul.tdx.com.cn',
+  strategy: Strategy.COOKIE,
+  navigateBefore: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: '返回数量' },
+  ],
+  columns: ['rank', 'symbol', 'name', 'changePercent', 'heat', 'tags'],
+  func: async (page, kwargs) => {
+    await page.goto(TDX_HOT_URL);
+    await page.wait({ timeout: 15000 });
+    const data = await page.evaluate(`
+      (() => {
+        const cleanText = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim();
+        const cells = document.querySelectorAll('div.top-cell[data-code]');
+        const results = [];
+        const seen = new Set();
+        cells.forEach((cell, idx) => {
+          const symbol = cell.getAttribute('data-code') || '';
+          const name = cell.getAttribute('data-name') || '';
+          if (!symbol || !name || seen.has(symbol)) return;
+          seen.add(symbol);
+          const tagEls = cell.querySelectorAll('div.tips-item.gnbk');
+          const tags = Array.from(tagEls).map(t => cleanText(t)).filter(Boolean).join(',');
+          results.push({
+            rank: idx + 1,
+            symbol,
+            name,
+            changePercent: cleanText(cell.querySelector('div.top-zf')),
+            heat: cleanText(cell.querySelector('div.hotN')),
+            tags,
+          });
+        });
+        return results;
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, kwargs.limit);
+  },
+});

package/clis/tdx/hot-rank.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './hot-rank.js';
+
+describe('tdx hot-rank command', () => {
+  it('registers the command with correct metadata', () => {
+    const command = getRegistry().get('tdx/hot-rank');
+    expect(command).toBeDefined();
+    expect(command).toMatchObject({
+      site: 'tdx',
+      name: 'hot-rank',
+      description: expect.stringContaining('通达信'),
+      domain: 'pul.tdx.com.cn',
+      navigateBefore: true,
+    });
+    expect(command.columns).toEqual(['rank', 'symbol', 'name', 'changePercent', 'heat', 'tags']);
+  });
+
+  it('returns hot stock data from the page', async () => {
+    const command = getRegistry().get('tdx/hot-rank');
+    const mockData = [
+      { rank: 1, symbol: '600519', name: '贵州茅台', changePercent: '+2.35%', heat: '1285', tags: '白酒', },
+      { rank: 2, symbol: '000001', name: '平安银行', changePercent: '-0.80%', heat: '856', tags: '银行', },
+    ];
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual(mockData[0]);
+  });
+
+  it('respects the limit parameter', async () => {
+    const command = getRegistry().get('tdx/hot-rank');
+    const mockData = Array.from({ length: 30 }, (_, i) => ({
+      rank: i + 1, symbol: `${i}`, name: `stock${i}`, changePercent: '0%', heat: '0', tags: '',
+    }));
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 10 });
+    expect(result).toHaveLength(10);
+  });
+
+  it('returns empty array when evaluate returns non-array', async () => {
+    const command = getRegistry().get('tdx/hot-rank');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(null),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toEqual([]);
+  });
+});

package/clis/ths/hot-rank.js

@@ -0,0 +1,49 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+
+const THS_HOT_URL = 'https://eq.10jqka.com.cn/webpage/ths-hot-list/index.html?showStatusBar=true';
+
+cli({
+  site: 'ths',
+  name: 'hot-rank',
+  description: '同花顺热股榜',
+  domain: 'eq.10jqka.com.cn',
+  strategy: Strategy.COOKIE,
+  navigateBefore: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: '返回数量' },
+  ],
+  columns: ['rank', 'name', 'changePercent', 'heat', 'tags'],
+  func: async (page, kwargs) => {
+    await page.goto(THS_HOT_URL);
+    await page.wait({ timeout: 15000 });
+    const data = await page.evaluate(`
+      (() => {
+        const cleanText = (el) => (el?.textContent || '').replace(/\\s+/g, ' ').trim();
+        const cards = document.querySelectorAll('div.pt-22.pb-24.bgc-white.border');
+        const results = [];
+        const seen = new Set();
+        cards.forEach((card, idx) => {
+          const row = card.querySelector('div.flex.bgc-white');
+          if (!row) return;
+          const nameEl = row.querySelector('span.ellipsis');
+          const name = cleanText(nameEl);
+          if (!name || seen.has(name)) return;
+          seen.add(name);
+          const tagEls = card.querySelectorAll('div.tag.PFSC-R');
+          const tags = Array.from(tagEls).map(t => cleanText(t)).filter(Boolean).join(',');
+          const rankEl = row.querySelector('div.THSMF-M.bold');
+          results.push({
+            rank: cleanText(rankEl) || String(idx + 1),
+            name,
+            changePercent: cleanText(row.querySelector('div.range')),
+            heat: cleanText(row.querySelector('div.col4 > span')),
+            tags,
+          });
+        });
+        return results;
+      })()
+    `);
+    if (!Array.isArray(data)) return [];
+    return data.slice(0, kwargs.limit);
+  },
+});

package/clis/ths/hot-rank.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './hot-rank.js';
+
+describe('ths hot-rank command', () => {
+  it('registers the command with correct metadata', () => {
+    const command = getRegistry().get('ths/hot-rank');
+    expect(command).toBeDefined();
+    expect(command).toMatchObject({
+      site: 'ths',
+      name: 'hot-rank',
+      description: expect.stringContaining('同花顺'),
+      domain: 'eq.10jqka.com.cn',
+      navigateBefore: true,
+    });
+    expect(command.columns).toEqual(['rank', 'name', 'changePercent', 'heat', 'tags']);
+  });
+
+  it('includes tags column', () => {
+    const command = getRegistry().get('ths/hot-rank');
+    expect(command.columns).toContain('tags');
+  });
+
+  it('returns hot stock data with tags field', async () => {
+    const command = getRegistry().get('ths/hot-rank');
+    const mockData = [
+      { rank: 1, name: '圣阳股份', changePercent: '+10.00%', heat: '28.5万', tags: '动力电池回收,钠离子电池' },
+    ];
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toHaveLength(1);
+    expect(result[0].tags).toBe('动力电池回收,钠离子电池');
+    expect(result[0].name).toBe('圣阳股份');
+  });
+
+  it('respects the limit parameter', async () => {
+    const command = getRegistry().get('ths/hot-rank');
+    const mockData = Array.from({ length: 30 }, (_, i) => ({
+      rank: i + 1, name: `stock${i}`, changePercent: '0%', heat: '0', tags: '',
+    }));
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(mockData),
+    };
+    const result = await command.func(page, { limit: 10 });
+    expect(result).toHaveLength(10);
+  });
+
+  it('returns empty array when evaluate returns non-array', async () => {
+    const command = getRegistry().get('ths/hot-rank');
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      wait: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue(null),
+    };
+    const result = await command.func(page, { limit: 20 });
+    expect(result).toEqual([]);
+  });
+});

package/clis/twitter/bookmarks.js

@@ -60,6 +60,7 @@ function extractBookmarkTweet(result, seen) {
         text: noteText || legacy.full_text || '',
         likes: legacy.favorite_count || 0,
         retweets: legacy.retweet_count || 0,
+        bookmarks: legacy.bookmark_count || 0,
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
     };
@@ -106,7 +107,7 @@ cli({
     args: [
         { name: 'limit', type: 'int', default: 20 },
     ],
-    columns: ['author', 'text', 'likes', 'url'],
+    columns: ['author', 'text', 'likes', 'retweets', 'bookmarks', 'url'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         await page.goto('https://x.com');