@jackwener/opencli 1.1.0 → 1.2.0

package/dist/clis/bloomberg/utils.js

@@ -0,0 +1,364 @@
+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',
+};
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (compatible; opencli)';
+export async function fetchBloombergFeed(name, limit = 1) {
+    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) {
+    const items = [];
+    const itemRegex = /<item\b[^>]*>([\s\S]*?)<\/item>/gi;
+    let match;
+    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) {
+    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) {
+    const normalized = normalizeBloombergLink(input);
+    let 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) {
+    const blocks = Array.isArray(body?.content) ? body.content : [];
+    const parts = blocks
+        .map((block) => renderBlock(block, 0))
+        .map((part) => normalizeBlockText(part))
+        .filter(Boolean);
+    return parts.join('\n\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+export function extractStoryMediaLinks(story) {
+    const urls = new Set();
+    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) => block?.type === 'media')
+        : [];
+    collectMediaUrls(mediaBlocks, urls);
+    return [...urls];
+}
+function renderBlock(block, depth) {
+    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) => 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) => renderBlock(child, depth + 1)).filter(Boolean);
+                if (nested.length)
+                    return nested.join('\n');
+            }
+            return extractGenericText(block);
+        }
+    }
+}
+function renderInlineNodes(nodes) {
+    return nodes.map((node) => renderInlineNode(node)).join('');
+}
+function renderInlineNode(node) {
+    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, depth) {
+    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) => {
+        const prefix = ordered ? `${index++}. ` : '- ';
+        return renderListItem(item, prefix, depth);
+    })
+        .filter(Boolean)
+        .join('\n');
+}
+function renderListItem(item, prefix, depth) {
+    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, depth) {
+    if (!item || typeof item !== 'object')
+        return '';
+    if (item.type === 'list-item' && Array.isArray(item.content)) {
+        const parts = item.content
+            .map((child) => child?.type === 'paragraph'
+            ? renderInlineNodes(child.content || [])
+            : renderBlock(child, depth))
+            .map((part) => normalizeBlockText(part))
+            .filter(Boolean);
+        return parts.join('\n');
+    }
+    return renderBlock(item, depth);
+}
+function renderTabularDataBlock(block) {
+    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) => extractGenericText(row))
+        .map((line) => normalizeBlockText(line))
+        .filter(Boolean);
+    return lines.join('\n');
+}
+function renderMediaBlock(block) {
+    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) {
+    const parts = [];
+    collectText(value, parts);
+    return parts.join(' ').replace(/\s+/g, ' ').trim();
+}
+function collectText(value, out) {
+    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, tag) {
+    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) {
+    const links = new Set();
+    const mediaRegex = /<(?:media:content|media:thumbnail|enclosure)\b[^>]*\burl="([^"]+)"[^>]*>/gi;
+    let match;
+    while ((match = mediaRegex.exec(block))) {
+        const url = decodeXmlEntities(match[1] || '').trim();
+        if (url)
+            links.add(url);
+    }
+    return [...links];
+}
+function collectMediaUrls(value, out, seen = new WeakSet()) {
+    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[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) {
+    const url = decodeXmlEntities(String(value || '')).trim();
+    if (!/^https?:\/\//i.test(url))
+        return null;
+    if (!looksLikeMediaUrl(url))
+        return null;
+    return url;
+}
+function looksLikeMediaUrl(url) {
+    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) {
+    const match = value.match(/^<!\[CDATA\[([\s\S]*?)\]\]>$/);
+    return match ? match[1] : value;
+}
+function stripHtml(value) {
+    return String(value || '').replace(/<[^>]+>/g, ' ');
+}
+function decodeXmlEntities(value) {
+    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) {
+    return String(value || '')
+        .replace(/\r/g, '')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n[ \t]+/g, '\n')
+        .replace(/[ \t]{2,}/g, ' ')
+        .trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/clis/bloomberg/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/bloomberg/utils.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest';
+import { extractStoryMediaLinks, parseBloombergRss, renderStoryBody } from './utils.js';
+describe('Bloomberg utils', () => {
+    it('parses Bloomberg RSS items with summary, link, and deduped media links', () => {
+        const xml = `<?xml version="1.0" encoding="UTF-8"?>
+      <rss xmlns:media="http://search.yahoo.com/mrss/">
+        <channel>
+          <item>
+            <title><![CDATA[Headline One]]></title>
+            <description><![CDATA[Summary <b>One</b> &amp; more]]></description>
+            <link>https://www.bloomberg.com/news/articles/2026-03-19/example-one</link>
+            <media:content url="https://assets.bwbx.io/example-one.jpg" type="image/jpeg">
+              <media:thumbnail url="https://assets.bwbx.io/example-one.jpg" />
+            </media:content>
+          </item>
+          <item>
+            <title>Headline Two</title>
+            <description>Summary Two</description>
+            <guid isPermaLink="true">https://www.bloomberg.com/news/articles/2026-03-19/example-two</guid>
+            <enclosure url="https://assets.bwbx.io/example-two.png" type="image/png" />
+          </item>
+        </channel>
+      </rss>`;
+        const items = parseBloombergRss(xml);
+        expect(items).toHaveLength(2);
+        expect(items[0]).toEqual({
+            title: 'Headline One',
+            summary: 'Summary One & more',
+            link: 'https://www.bloomberg.com/news/articles/2026-03-19/example-one',
+            mediaLinks: ['https://assets.bwbx.io/example-one.jpg'],
+        });
+        expect(items[1]).toEqual({
+            title: 'Headline Two',
+            summary: 'Summary Two',
+            link: 'https://www.bloomberg.com/news/articles/2026-03-19/example-two',
+            mediaLinks: ['https://assets.bwbx.io/example-two.png'],
+        });
+    });
+    it('renders Bloomberg story rich-text body into readable text', () => {
+        const body = {
+            type: 'document',
+            content: [
+                { type: 'inline-newsletter', data: { position: 'top' }, content: [] },
+                {
+                    type: 'paragraph',
+                    data: {},
+                    content: [
+                        { type: 'text', value: 'Lead paragraph with ' },
+                        { type: 'entity', content: [{ type: 'text', value: 'linked text' }] },
+                        { type: 'text', value: '.' },
+                    ],
+                },
+                {
+                    type: 'heading',
+                    data: { level: 2 },
+                    content: [{ type: 'text', value: 'Key Points' }],
+                },
+                {
+                    type: 'list',
+                    data: { style: 'unordered' },
+                    content: [
+                        {
+                            type: 'list-item',
+                            content: [
+                                { type: 'paragraph', content: [{ type: 'text', value: 'Point one' }] },
+                            ],
+                        },
+                        {
+                            type: 'list-item',
+                            content: [
+                                { type: 'paragraph', content: [{ type: 'text', value: 'Point two' }] },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    type: 'blockquote',
+                    content: [{ type: 'text', value: 'Quoted line' }],
+                },
+                {
+                    type: 'media',
+                    data: {
+                        attachment: {
+                            caption: '<p>Chart caption</p>',
+                        },
+                    },
+                },
+                { type: 'ad', data: { num: 1 }, content: [] },
+            ],
+        };
+        expect(renderStoryBody(body)).toBe([
+            'Lead paragraph with linked text.',
+            '## Key Points',
+            '- Point one\n- Point two',
+            '> Quoted line',
+            'Chart caption',
+        ].join('\n\n'));
+    });
+    it('collects deduped story media links from lede, attachments, and body media', () => {
+        const story = {
+            ledeImageUrl: 'https://assets.bwbx.io/lede.webp',
+            lede: { url: 'https://assets.bwbx.io/lede.webp' },
+            socialImageUrl: 'https://assets.bwbx.io/social.png',
+            imageAttachments: {
+                one: { url: 'https://assets.bwbx.io/figure.jpg' },
+            },
+            body: {
+                content: [
+                    {
+                        type: 'media',
+                        data: {
+                            chart: {
+                                src: 'https://resource.bloomberg.com/images/chart.png',
+                                fallback: 'https://assets.bwbx.io/chart-fallback.png',
+                            },
+                        },
+                    },
+                ],
+            },
+        };
+        expect(extractStoryMediaLinks(story)).toEqual([
+            'https://assets.bwbx.io/lede.webp',
+            'https://assets.bwbx.io/social.png',
+            'https://assets.bwbx.io/figure.jpg',
+            'https://resource.bloomberg.com/images/chart.png',
+            'https://assets.bwbx.io/chart-fallback.png',
+        ]);
+    });
+});

package/dist/clis/boss/batchgreet.js

@@ -1,56 +1,30 @@
 /**
  * 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 { requirePage, navigateToChat, fetchRecommendList, clickCandidateInList, typeAndSendMessage, verbose, } from './common.js';
 cli({
     site: 'boss',
     name: 'batchgreet',
     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, kwargs) => {
-        if (!page)
-            throw new Error('Browser page required');
-        const filterJobId = kwargs.job_id || '';
+        requirePage(page);
+        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 });
-        // Get recommended candidates
-        const listData = 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();
-        });
-      }
-    `);
-        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 || [];
+        verbose(`Batch greeting up to ${limit} candidates...`);
+        await navigateToChat(page, 3);
+        let candidates = await fetchRecommendList(page);
         if (filterJobId) {
             candidates = candidates.filter((f) => f.encryptJobId === filterJobId);
         }
@@ -63,78 +37,17 @@ cli({
             const numericUid = candidate.uid;
             const friendName = candidate.name || '候选人';
             try {
-                // Click on candidate
-                const clicked = 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 = 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 = 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 });
             }