@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/bloomberg/main.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchBloombergFeed } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'main',
+    description: 'Bloomberg homepage top stories (RSS)',
+    domain: 'feeds.bloomberg.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 1, help: 'Number of feed items to return (max 20)' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks'],
+    func: async (_page, kwargs) => {
+        return fetchBloombergFeed('main', kwargs.limit ?? 1);
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/markets.d.ts

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

package/vendor/opencli/dist/clis/bloomberg/markets.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchBloombergFeed } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'markets',
+    description: 'Bloomberg Markets top stories (RSS)',
+    domain: 'feeds.bloomberg.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 1, help: 'Number of feed items to return (max 20)' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks'],
+    func: async (_page, kwargs) => {
+        return fetchBloombergFeed('markets', kwargs.limit ?? 1);
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/news.d.ts

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

package/vendor/opencli/dist/clis/bloomberg/news.js

@@ -0,0 +1,105 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { extractStoryMediaLinks, renderStoryBody, validateBloombergLink, } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'news',
+    description: 'Read a Bloomberg story/article page and return title, full content, and media links',
+    domain: 'www.bloomberg.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'link', positional: true, required: true, help: 'Bloomberg story/article URL or relative Bloomberg path' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks', 'content'],
+    func: async (page, kwargs) => {
+        const url = validateBloombergLink(kwargs.link);
+        // Navigate and wait for the page to hydrate before extracting story data.
+        await page.goto(url);
+        await page.wait({ selector: 'article', timeout: 5 });
+        const loadStory = async () => page.evaluate(`(() => {
+      const isRobot = /Are you a robot/i.test(document.title)
+        || /unusual activity/i.test(document.body.innerText)
+        || /click the box below to let us know you're not a robot/i.test(document.body.innerText);
+
+      if (isRobot) {
+        return {
+          errorCode: 'ROBOT_PAGE',
+          title: document.title,
+          preview: document.body.innerText.slice(0, 400),
+        };
+      }
+
+      const raw = document.querySelector('#__NEXT_DATA__')?.textContent;
+      if (!raw) {
+        return {
+          errorCode: 'NO_NEXT_DATA',
+          title: document.title,
+          preview: document.body.innerText.slice(0, 400),
+        };
+      }
+
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch (err) {
+        return {
+          errorCode: 'BAD_NEXT_DATA',
+          title: document.title,
+          preview: document.body.innerText.slice(0, 400),
+          message: String(err),
+        };
+      }
+
+      const story = parsed?.props?.pageProps?.story;
+      if (!story) {
+        return {
+          errorCode: 'NO_STORY',
+          title: document.title,
+          preview: document.body.innerText.slice(0, 400),
+        };
+      }
+
+      return {
+        story: {
+          headline: story.headline || story.seoHeadline || story.seoTitle || document.querySelector('h1')?.textContent?.trim() || document.title,
+          summary: story.summary || story.socialDescription || story.seoDescription || document.querySelector('meta[name="description"]')?.getAttribute('content') || '',
+          url: story.url || story.readingUrl || location.href,
+          body: story.body || null,
+          lede: story.lede || null,
+          ledeImageUrl: story.ledeImageUrl || null,
+          socialImageUrl: story.socialImageUrl || null,
+          imageAttachments: story.imageAttachments || {},
+          videoAttachments: story.videoAttachments || {},
+        }
+      };
+    })()`);
+        let result = await loadStory();
+        // Retry once — Bloomberg pages sometimes hydrate slowly.
+        if (result?.errorCode === 'NO_NEXT_DATA' || result?.errorCode === 'NO_STORY') {
+            await page.wait(4);
+            result = await loadStory();
+        }
+        if (result?.errorCode === 'ROBOT_PAGE') {
+            throw new CliError('FETCH_ERROR', 'Bloomberg served the bot-protection page instead of article content', 'Try again later or open the article in a regular Chrome session first, then rerun the command. This command uses your current Bloomberg access and does not bypass paywall or entitlement checks.');
+        }
+        if (result?.errorCode) {
+            throw new CliError('PARSE_ERROR', `Bloomberg page did not expose article story data (${result.errorCode})`, 'This command currently works on standard Bloomberg story/article pages that expose __NEXT_DATA__. Audio, video, newsletter, or other non-standard/blocked pages may not work. Access still depends on your current Bloomberg session.');
+        }
+        const story = result?.story;
+        if (!story) {
+            throw new CliError('PARSE_ERROR', 'Failed to extract Bloomberg story data', 'Bloomberg may have changed the page structure.');
+        }
+        const content = renderStoryBody(story.body);
+        if (!content) {
+            throw new CliError('PARSE_ERROR', 'Bloomberg article body was empty after parsing', 'Bloomberg may have changed the story-body format, the URL may not point to a standard article page, or the page may not be accessible in your current Bloomberg session.');
+        }
+        return [{
+                title: story.headline || '',
+                summary: story.summary || '',
+                link: story.url || url,
+                mediaLinks: extractStoryMediaLinks(story),
+                content,
+            }];
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/opinions.d.ts

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

package/vendor/opencli/dist/clis/bloomberg/opinions.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchBloombergFeed } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'opinions',
+    description: 'Bloomberg Opinion top stories (RSS)',
+    domain: 'feeds.bloomberg.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 1, help: 'Number of feed items to return (max 20)' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks'],
+    func: async (_page, kwargs) => {
+        return fetchBloombergFeed('opinions', kwargs.limit ?? 1);
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/politics.d.ts

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

package/vendor/opencli/dist/clis/bloomberg/politics.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchBloombergFeed } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'politics',
+    description: 'Bloomberg Politics top stories (RSS)',
+    domain: 'feeds.bloomberg.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 1, help: 'Number of feed items to return (max 20)' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks'],
+    func: async (_page, kwargs) => {
+        return fetchBloombergFeed('politics', kwargs.limit ?? 1);
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/tech.d.ts

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

package/vendor/opencli/dist/clis/bloomberg/tech.js

@@ -0,0 +1,17 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchBloombergFeed } from './utils.js';
+cli({
+    site: 'bloomberg',
+    name: 'tech',
+    description: 'Bloomberg Tech top stories (RSS)',
+    domain: 'feeds.bloomberg.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'limit', type: 'int', default: 1, help: 'Number of feed items to return (max 20)' },
+    ],
+    columns: ['title', 'summary', 'link', 'mediaLinks'],
+    func: async (_page, kwargs) => {
+        return fetchBloombergFeed('tech', kwargs.limit ?? 1);
+    },
+});

package/vendor/opencli/dist/clis/bloomberg/utils.d.ts

@@ -0,0 +1,34 @@
+export declare const BLOOMBERG_FEEDS: {
+    readonly main: "https://feeds.bloomberg.com/news.rss";
+    readonly markets: "https://feeds.bloomberg.com/markets/news.rss";
+    readonly economics: "https://feeds.bloomberg.com/economics/news.rss";
+    readonly industries: "https://feeds.bloomberg.com/industries/news.rss";
+    readonly tech: "https://feeds.bloomberg.com/technology/news.rss";
+    readonly politics: "https://feeds.bloomberg.com/politics/news.rss";
+    readonly businessweek: "https://feeds.bloomberg.com/businessweek/news.rss";
+    readonly opinions: "https://feeds.bloomberg.com/bview/news.rss";
+};
+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 declare function fetchBloombergFeed(name: BloombergFeedName, limit?: number): Promise<BloombergFeedItem[]>;
+export declare function parseBloombergRss(xml: string): BloombergFeedItem[];
+export declare function normalizeBloombergLink(input: string): string;
+export declare function validateBloombergLink(input: string): string;
+export declare function renderStoryBody(body: any): string;
+export declare function extractStoryMediaLinks(story: BloombergStory): string[];

package/vendor/opencli/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/vendor/opencli/dist/clis/bloomberg/utils.test.d.ts

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