@jackwener/opencli 1.1.0 → 1.2.0

package/src/clis/bloomberg/utils.ts

@@ -0,0 +1,429 @@
+import { CliError } from '../../errors.js';
+
+export const BLOOMBERG_FEEDS = {
+  main: 'https://feeds.bloomberg.com/news.rss',
+  markets: 'https://feeds.bloomberg.com/markets/news.rss',
+  economics: 'https://feeds.bloomberg.com/economics/news.rss',
+  industries: 'https://feeds.bloomberg.com/industries/news.rss',
+  tech: 'https://feeds.bloomberg.com/technology/news.rss',
+  politics: 'https://feeds.bloomberg.com/politics/news.rss',
+  businessweek: 'https://feeds.bloomberg.com/businessweek/news.rss',
+  opinions: 'https://feeds.bloomberg.com/bview/news.rss',
+} as const;
+
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; opencli)';
+
+export type BloombergFeedName = keyof typeof BLOOMBERG_FEEDS;
+
+export interface BloombergFeedItem {
+  title: string;
+  summary: string;
+  link: string;
+  mediaLinks: string[];
+}
+
+export interface BloombergStory {
+  headline?: string;
+  summary?: string;
+  url?: string;
+  body?: any;
+  lede?: any;
+  ledeImageUrl?: string;
+  socialImageUrl?: string;
+  imageAttachments?: Record<string, any>;
+  videoAttachments?: Record<string, any>;
+}
+
+export async function fetchBloombergFeed(name: BloombergFeedName, limit: number = 1): Promise<BloombergFeedItem[]> {
+  const feedUrl = BLOOMBERG_FEEDS[name];
+  if (!feedUrl) {
+    throw new CliError('ARGUMENT', `Unknown Bloomberg feed: ${name}`);
+  }
+
+  const resp = await fetch(feedUrl, {
+    headers: { 'User-Agent': DEFAULT_USER_AGENT },
+  });
+
+  if (!resp.ok) {
+    throw new CliError(
+      'FETCH_ERROR',
+      `Bloomberg RSS HTTP ${resp.status}`,
+      'Bloomberg may be temporarily unavailable; try again later.',
+    );
+  }
+
+  const xml = await resp.text();
+  const items = parseBloombergRss(xml);
+  if (!items.length) {
+    throw new CliError(
+      'NOT_FOUND',
+      'Bloomberg RSS feed returned no items',
+      'Bloomberg may have changed the feed format.',
+    );
+  }
+
+  const count = Math.max(1, Math.min(Number(limit) || 1, 20));
+  return items.slice(0, count);
+}
+
+export function parseBloombergRss(xml: string): BloombergFeedItem[] {
+  const items: BloombergFeedItem[] = [];
+  const itemRegex = /<item\b[^>]*>([\s\S]*?)<\/item>/gi;
+  let match: RegExpExecArray | null;
+
+  while ((match = itemRegex.exec(xml))) {
+    const block = match[1];
+    const title = extractTagText(block, 'title');
+    const summary = extractTagText(block, 'description');
+    const link = extractTagText(block, 'link') || extractTagText(block, 'guid');
+    const mediaLinks = extractMediaLinksFromRssItem(block);
+
+    if (!title || !link) continue;
+    items.push({
+      title,
+      summary,
+      link,
+      mediaLinks,
+    });
+  }
+
+  return items;
+}
+
+export function normalizeBloombergLink(input: string): string {
+  const raw = String(input || '').trim();
+  if (!raw) {
+    throw new CliError('ARGUMENT', 'A Bloomberg link is required');
+  }
+  if (raw.startsWith('/')) return `https://www.bloomberg.com${raw}`;
+  return raw;
+}
+
+export function validateBloombergLink(input: string): string {
+  const normalized = normalizeBloombergLink(input);
+  let url: URL;
+  try {
+    url = new URL(normalized);
+  } catch {
+    throw new CliError(
+      'ARGUMENT',
+      `Invalid Bloomberg link: ${input}`,
+      'Pass a full https://www.bloomberg.com/... URL or a relative Bloomberg path.',
+    );
+  }
+
+  if (!/(?:\.|^)bloomberg\.com$/i.test(url.hostname)) {
+    throw new CliError(
+      'ARGUMENT',
+      `Expected a bloomberg.com link, got: ${url.hostname}`,
+      'Pass a Bloomberg article URL from bloomberg.com.',
+    );
+  }
+
+  return url.toString();
+}
+
+export function renderStoryBody(body: any): string {
+  const blocks = Array.isArray(body?.content) ? body.content : [];
+  const parts = blocks
+    .map((block: any) => renderBlock(block, 0))
+    .map((part: string) => normalizeBlockText(part))
+    .filter(Boolean);
+
+  return parts.join('\n\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+export function extractStoryMediaLinks(story: BloombergStory): string[] {
+  const urls = new Set<string>();
+  collectMediaUrls(story?.ledeImageUrl, urls);
+  collectMediaUrls(story?.socialImageUrl, urls);
+  collectMediaUrls(story?.lede, urls);
+  collectMediaUrls(story?.imageAttachments, urls);
+  collectMediaUrls(story?.videoAttachments, urls);
+
+  const mediaBlocks = Array.isArray(story?.body?.content)
+    ? story.body.content.filter((block: any) => block?.type === 'media')
+    : [];
+  collectMediaUrls(mediaBlocks, urls);
+
+  return [...urls];
+}
+
+function renderBlock(block: any, depth: number): string {
+  if (!block || typeof block !== 'object') return '';
+
+  switch (block.type) {
+    case 'paragraph':
+      return renderInlineNodes(block.content || []);
+    case 'heading': {
+      const text = renderInlineNodes(block.content || []);
+      if (!text) return '';
+      const level = Number(block.data?.level ?? block.data?.weight ?? 2);
+      const prefix = level <= 1 ? '# ' : level === 2 ? '## ' : '### ';
+      return `${prefix}${text}`;
+    }
+    case 'blockquote': {
+      const text = renderInlineNodes(block.content || []);
+      if (!text) return '';
+      return text.split('\n').map((line: string) => line ? `> ${line}` : '>').join('\n');
+    }
+    case 'list':
+      return renderListBlock(block, depth);
+    case 'tabularData':
+      return renderTabularDataBlock(block);
+    case 'media':
+      return renderMediaBlock(block);
+    case 'inline-newsletter':
+    case 'newsletter':
+    case 'ad':
+      return '';
+    default: {
+      if (Array.isArray(block.content) && block.content.length > 0) {
+        const inlineText = renderInlineNodes(block.content);
+        if (inlineText) return inlineText;
+        const nested = block.content.map((child: any) => renderBlock(child, depth + 1)).filter(Boolean);
+        if (nested.length) return nested.join('\n');
+      }
+      return extractGenericText(block);
+    }
+  }
+}
+
+function renderInlineNodes(nodes: any[]): string {
+  return nodes.map((node) => renderInlineNode(node)).join('');
+}
+
+function renderInlineNode(node: any): string {
+  if (node == null) return '';
+  if (typeof node === 'string') return decodeXmlEntities(node);
+
+  switch (node.type) {
+    case 'text':
+      return decodeXmlEntities(node.value || '');
+    case 'linebreak':
+      return '\n';
+    case 'link':
+    case 'entity':
+    case 'strong':
+    case 'emphasis':
+    case 'italic':
+    case 'underline':
+    case 'span':
+      if (Array.isArray(node.content) && node.content.length > 0) {
+        return renderInlineNodes(node.content);
+      }
+      return decodeXmlEntities(node.value || '');
+    default:
+      if (Array.isArray(node.content) && node.content.length > 0) {
+        return renderInlineNodes(node.content);
+      }
+      if (typeof node.value === 'string') return decodeXmlEntities(node.value);
+      return '';
+  }
+}
+
+function renderListBlock(block: any, depth: number): string {
+  const items = Array.isArray(block.content) ? block.content : [];
+  if (!items.length) return '';
+
+  const listStyle = String(block.subType || block.data?.style || block.data?.listType || '');
+  const ordered = /\bordered\b|\bnumber(?:ed)?\b/i.test(listStyle);
+  let index = 1;
+
+  return items
+    .map((item: any) => {
+      const prefix = ordered ? `${index++}. ` : '- ';
+      return renderListItem(item, prefix, depth);
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function renderListItem(item: any, prefix: string, depth: number): string {
+  const indent = '  '.repeat(depth);
+  const body = normalizeBlockText(renderListItemBody(item, depth + 1));
+  if (!body) return '';
+
+  const lines = body.split('\n');
+  const head = `${indent}${prefix}${lines[0]}`;
+  if (lines.length === 1) return head;
+
+  const continuationIndent = `${indent}${' '.repeat(prefix.length)}`;
+  const tail = lines.slice(1).map((line) => `${continuationIndent}${line}`).join('\n');
+  return `${head}\n${tail}`;
+}
+
+function renderListItemBody(item: any, depth: number): string {
+  if (!item || typeof item !== 'object') return '';
+
+  if (item.type === 'list-item' && Array.isArray(item.content)) {
+    const parts = item.content
+      .map((child: any) => child?.type === 'paragraph'
+        ? renderInlineNodes(child.content || [])
+        : renderBlock(child, depth))
+      .map((part: string) => normalizeBlockText(part))
+      .filter(Boolean);
+    return parts.join('\n');
+  }
+
+  return renderBlock(item, depth);
+}
+
+function renderTabularDataBlock(block: any): string {
+  const rows = block?.data?.rows ?? block?.data?.table?.rows ?? block?.content;
+  if (!Array.isArray(rows) || !rows.length) {
+    return extractGenericText(block.data || block.content || block);
+  }
+
+  const lines = rows
+    .map((row: any) => extractGenericText(row))
+    .map((line) => normalizeBlockText(line))
+    .filter(Boolean);
+
+  return lines.join('\n');
+}
+
+function renderMediaBlock(block: any): string {
+  const candidates = [
+    block?.data?.chart?.caption,
+    block?.data?.attachment?.caption,
+    block?.data?.attachment?.title,
+    block?.data?.attachment?.subtitle,
+    block?.data?.video?.caption,
+  ];
+
+  const caption = candidates
+    .map((value) => normalizeBlockText(stripHtml(String(value || ''))))
+    .find(Boolean);
+
+  return caption || '';
+}
+
+function extractGenericText(value: any): string {
+  const parts: string[] = [];
+  collectText(value, parts);
+  return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+
+function collectText(value: any, out: string[]): void {
+  if (value == null) return;
+  if (typeof value === 'string') {
+    const text = normalizeBlockText(stripHtml(decodeXmlEntities(value)));
+    if (text) out.push(text);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) collectText(item, out);
+    return;
+  }
+  if (typeof value === 'object') {
+    if (typeof value.value === 'string') {
+      const text = normalizeBlockText(stripHtml(decodeXmlEntities(value.value)));
+      if (text) out.push(text);
+      return;
+    }
+    if (Array.isArray(value.content)) {
+      collectText(value.content, out);
+      return;
+    }
+    for (const entry of Object.values(value)) collectText(entry, out);
+  }
+}
+
+function extractTagText(block: string, tag: string): string {
+  const safeTag = escapeRegExp(tag);
+  const match = block.match(new RegExp(`<${safeTag}(?:\\s[^>]*)?>([\\s\\S]*?)<\\/${safeTag}>`, 'i'));
+  if (!match) return '';
+  return normalizeBlockText(stripHtml(decodeXmlEntities(stripCdata(match[1]))));
+}
+
+function extractMediaLinksFromRssItem(block: string): string[] {
+  const links = new Set<string>();
+  const mediaRegex = /<(?:media:content|media:thumbnail|enclosure)\b[^>]*\burl="([^"]+)"[^>]*>/gi;
+  let match: RegExpExecArray | null;
+  while ((match = mediaRegex.exec(block))) {
+    const url = decodeXmlEntities(match[1] || '').trim();
+    if (url) links.add(url);
+  }
+  return [...links];
+}
+
+function collectMediaUrls(value: any, out: Set<string>, seen = new WeakSet<object>()): void {
+  if (value == null) return;
+
+  if (typeof value === 'string') {
+    const normalized = normalizeMediaUrl(value);
+    if (normalized) out.add(normalized);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) collectMediaUrls(item, out, seen);
+    return;
+  }
+
+  if (typeof value === 'object') {
+    if (seen.has(value)) return;
+    seen.add(value);
+
+    for (const key of ['url', 'src', 'fallback', 'poster']) {
+      const candidate = (value as Record<string, any>)[key];
+      if (typeof candidate === 'string') {
+        const normalized = normalizeMediaUrl(candidate);
+        if (normalized) out.add(normalized);
+      }
+    }
+
+    for (const entry of Object.values(value)) {
+      collectMediaUrls(entry, out, seen);
+    }
+  }
+}
+
+function normalizeMediaUrl(value: string): string | null {
+  const url = decodeXmlEntities(String(value || '')).trim();
+  if (!/^https?:\/\//i.test(url)) return null;
+  if (!looksLikeMediaUrl(url)) return null;
+  return url;
+}
+
+function looksLikeMediaUrl(url: string): boolean {
+  return /(?:assets\.bwbx\.io|resource\.bloomberg\.com|media\.bloomberg\.com)/i.test(url)
+    || /\.(?:jpg|jpeg|png|webp|gif|svg|mp4|m3u8)(?:[?#].*)?$/i.test(url);
+}
+
+function stripCdata(value: string): string {
+  const match = value.match(/^<!\[CDATA\[([\s\S]*?)\]\]>$/);
+  return match ? match[1] : value;
+}
+
+function stripHtml(value: string): string {
+  return String(value || '').replace(/<[^>]+>/g, ' ');
+}
+
+function decodeXmlEntities(value: string): string {
+  return String(value || '')
+    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+    .replace(/&#(\d+);/g, (_m, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-f]+);/gi, (_m, code) => String.fromCodePoint(parseInt(code, 16)))
+    .replace(/&amp;/g, '&')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&apos;/g, "'")
+    .replace(/&nbsp;/g, ' ');
+}
+
+function normalizeBlockText(value: string): string {
+  return String(value || '')
+    .replace(/\r/g, '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n[ \t]+/g, '\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim();
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/clis/boss/batchgreet.ts

@@ -1,11 +1,11 @@
 /**
  * BOSS直聘 batchgreet — batch greet recommended candidates.
- *
- * Combines recommend (greetRecSortList) + greet (UI automation).
- * Sends greeting messages to multiple candidates sequentially.
  */
 import { cli, Strategy } from '../../registry.js';
-import type { IPage } from '../../types.js';
+import {
+  requirePage, navigateToChat, fetchRecommendList,
+  clickCandidateInList, typeAndSendMessage, verbose,
+} from './common.js';
 
 cli({
   site: 'boss',
@@ -13,51 +13,26 @@ cli({
   description: 'BOSS直聘批量向推荐候选人发送招呼',
   domain: 'www.zhipin.com',
   strategy: Strategy.COOKIE,
+  navigateBefore: false,
   browser: true,
   args: [
-    { name: 'job_id', default: '', help: 'Filter by encrypted job ID (greet all jobs if empty)' },
+    { name: 'job-id', default: '', help: 'Filter by encrypted job ID (greet all jobs if empty)' },
     { name: 'limit', type: 'int', default: 5, help: 'Max candidates to greet' },
     { name: 'text', default: '', help: 'Custom greeting message (uses default if empty)' },
   ],
   columns: ['name', 'status', 'detail'],
-  func: async (page: IPage | null, kwargs) => {
-    if (!page) throw new Error('Browser page required');
+  func: async (page, kwargs) => {
+    requirePage(page);
 
-    const filterJobId = kwargs.job_id || '';
+    const filterJobId = kwargs['job-id'] || '';
     const limit = kwargs.limit || 5;
     const text = kwargs.text || '你好，请问您对这个职位感兴趣吗？';
 
-    if (process.env.OPENCLI_VERBOSE) {
-      console.error(`[opencli:boss] Batch greeting up to ${limit} candidates...`);
-    }
-
-    await page.goto('https://www.zhipin.com/web/chat/index');
-    await page.wait({ time: 3 });
+    verbose(`Batch greeting up to ${limit} candidates...`);
 
-    // Get recommended candidates
-    const listData: any = await page.evaluate(`
-      async () => {
-        return new Promise((resolve, reject) => {
-          const xhr = new XMLHttpRequest();
-          xhr.open('GET', 'https://www.zhipin.com/wapi/zprelation/friend/greetRecSortList', true);
-          xhr.withCredentials = true;
-          xhr.timeout = 15000;
-          xhr.setRequestHeader('Accept', 'application/json');
-          xhr.onload = () => { try { resolve(JSON.parse(xhr.responseText)); } catch(e) { reject(e); } };
-          xhr.onerror = () => reject(new Error('Network Error'));
-          xhr.send();
-        });
-      }
-    `);
+    await navigateToChat(page, 3);
 
-    if (listData.code !== 0) {
-      if (listData.code === 7 || listData.code === 37) {
-        throw new Error('Cookie 已过期！请在当前 Chrome 浏览器中重新登录 BOSS 直聘。');
-      }
-      throw new Error(`获取推荐列表失败: ${listData.message}`);
-    }
-
-    let candidates = listData.zpData?.friendList || [];
+    let candidates = await fetchRecommendList(page);
     if (filterJobId) {
       candidates = candidates.filter((f: any) => f.encryptJobId === filterJobId);
     }
@@ -74,88 +49,21 @@ cli({
       const friendName = candidate.name || '候选人';
 
       try {
-        // Click on candidate
-        const clicked: any = await page.evaluate(`
-          async () => {
-            const item = document.querySelector('#_${numericUid}-0') || document.querySelector('[id^="_${numericUid}"]');
-            if (item) {
-              item.click();
-              return { clicked: true };
-            }
-            const items = document.querySelectorAll('.geek-item');
-            for (const el of items) {
-              if (el.id && el.id.startsWith('_${numericUid}')) {
-                el.click();
-                return { clicked: true };
-              }
-            }
-            return { clicked: false };
-          }
-        `);
-
-        if (!clicked.clicked) {
+        const clicked = await clickCandidateInList(page, numericUid);
+        if (!clicked) {
           results.push({ name: friendName, status: '❌ 跳过', detail: '在聊天列表中未找到' });
           continue;
         }
 
         await page.wait({ time: 2 });
 
-        // Type message
-        const typed: any = await page.evaluate(`
-          async () => {
-            const selectors = [
-              '.chat-editor [contenteditable="true"]',
-              '.chat-input [contenteditable="true"]',
-              '[contenteditable="true"]',
-              'textarea',
-            ];
-            for (const sel of selectors) {
-              const el = document.querySelector(sel);
-              if (el && el.offsetParent !== null) {
-                el.focus();
-                if (el.tagName === 'TEXTAREA' || el.tagName === 'INPUT') {
-                  el.value = ${JSON.stringify(text)};
-                  el.dispatchEvent(new Event('input', { bubbles: true }));
-                } else {
-                  el.textContent = '';
-                  el.focus();
-                  document.execCommand('insertText', false, ${JSON.stringify(text)});
-                  el.dispatchEvent(new Event('input', { bubbles: true }));
-                }
-                return { found: true };
-              }
-            }
-            return { found: false };
-          }
-        `);
-
-        if (!typed.found) {
+        const sent = await typeAndSendMessage(page, text);
+        if (!sent) {
           results.push({ name: friendName, status: '❌ 失败', detail: '找不到消息输入框' });
           continue;
         }
 
-        await page.wait({ time: 0.5 });
-
-        // Click send
-        const sent: any = await page.evaluate(`
-          async () => {
-            const btn = document.querySelector('.conversation-editor .submit') 
-                     || document.querySelector('.submit-content .submit')
-                     || document.querySelector('.conversation-operate .submit');
-            if (btn) {
-              btn.click();
-              return { clicked: true };
-            }
-            return { clicked: false };
-          }
-        `);
-
-        if (!sent.clicked) {
-          await page.pressKey('Enter');
-        }
-
         await page.wait({ time: 1.5 });
-
         results.push({ name: friendName, status: '✅ 已发送', detail: text });
       } catch (e: any) {
         results.push({ name: friendName, status: '❌ 失败', detail: e.message?.substring(0, 80) || '未知错误' });

package/src/clis/boss/chatlist.ts

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import type { IPage } from '../../types.js';
+import { requirePage, navigateToChat, fetchFriendList } from './common.js';
 
 cli({
   site: 'boss',
@@ -7,38 +7,24 @@ cli({
   description: 'BOSS直聘查看聊天列表（招聘端）',
   domain: 'www.zhipin.com',
   strategy: Strategy.COOKIE,
+  navigateBefore: false,
   browser: true,
   args: [
     { name: 'page', type: 'int', default: 1, help: 'Page number' },
     { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
-    { name: 'job_id', default: '0', help: 'Filter by job ID (0=all)' },
+    { name: 'job-id', default: '0', help: 'Filter by job ID (0=all)' },
   ],
   columns: ['name', 'job', 'last_msg', 'last_time', 'uid', 'security_id'],
-  func: async (page: IPage | null, kwargs) => {
-    if (!page) throw new Error('Browser page required');
-    await page.goto('https://www.zhipin.com/web/chat/index');
-    await page.wait({ time: 2 });
-    const jobId = kwargs.job_id || '0';
-    const pageNum = kwargs.page || 1;
-    const limit = kwargs.limit || 20;
-    const targetUrl = `https://www.zhipin.com/wapi/zprelation/friend/getBossFriendListV2.json?page=${pageNum}&status=0&jobId=${jobId}`;
-    const data: any = await page.evaluate(`
-      async () => {
-        return new Promise((resolve, reject) => {
-          const xhr = new XMLHttpRequest();
-          xhr.open('GET', '${targetUrl}', true);
-          xhr.withCredentials = true;
-          xhr.timeout = 15000;
-          xhr.setRequestHeader('Accept', 'application/json');
-          xhr.onload = () => { try { resolve(JSON.parse(xhr.responseText)); } catch(e) { reject(new Error('JSON parse failed')); } };
-          xhr.onerror = () => reject(new Error('Network Error'));
-          xhr.send();
-        });
-      }
-    `);
-    if (data.code !== 0) throw new Error(`API error: ${data.message} (code=${data.code})`);
-    const friends = (data.zpData?.friendList || []).slice(0, limit);
-    return friends.map((f: any) => ({
+  func: async (page, kwargs) => {
+    requirePage(page);
+    await navigateToChat(page);
+
+    const friends = await fetchFriendList(page, {
+      pageNum: kwargs.page || 1,
+      jobId: kwargs['job-id'] || '0',
+    });
+
+    return friends.slice(0, kwargs.limit || 20).map((f: any) => ({
       name: f.name || '',
       job: f.jobName || '',
       last_msg: f.lastMessageInfo?.text || '',