@jackwener/opencli 1.1.0 → 1.1.1

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

@@ -13,7 +13,7 @@ cli({
     strategy: Strategy.COOKIE,
     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)' },
     ],
@@ -21,7 +21,7 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Browser page required');
-        const filterJobId = kwargs.job_id || '';
+        const filterJobId = kwargs['job-id'] || '';
         const limit = kwargs.limit || 5;
         const text = kwargs.text || '你好，请问您对这个职位感兴趣吗？';
         if (process.env.OPENCLI_VERBOSE) {

package/dist/clis/boss/chatlist.js

@@ -9,7 +9,7 @@ cli({
     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, kwargs) => {
@@ -17,7 +17,7 @@ cli({
             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 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}`;

package/dist/clis/boss/detail.js

@@ -13,7 +13,7 @@ cli({
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'security_id', required: true, help: 'Security ID from search results (securityId field)' },
+        { name: 'security-id', required: true, help: 'Security ID from search results (securityId field)' },
     ],
     columns: [
         'name', 'salary', 'experience', 'degree', 'city', 'district',
@@ -25,7 +25,7 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Browser page required');
-        const securityId = kwargs.security_id;
+        const securityId = kwargs['security-id'];
         // Navigate to zhipin.com first to establish cookie context (referrer + cookies)
         await page.goto('https://www.zhipin.com/web/geek/job');
         await page.wait({ time: 1 });

package/dist/clis/boss/greet.js

@@ -18,8 +18,8 @@ cli({
     browser: true,
     args: [
         { name: 'uid', required: true, help: 'Encrypted UID of the candidate (from recommend)' },
-        { name: 'security_id', required: true, help: 'Security ID of the candidate' },
-        { name: 'job_id', required: true, help: 'Encrypted job ID' },
+        { name: 'security-id', required: true, help: 'Security ID of the candidate' },
+        { name: 'job-id', required: true, help: 'Encrypted job ID' },
         { name: 'text', default: '', help: 'Custom greeting message (uses default template if empty)' },
     ],
     columns: ['status', 'detail'],
@@ -27,8 +27,8 @@ cli({
         if (!page)
             throw new Error('Browser page required');
         const uid = kwargs.uid;
-        const securityId = kwargs.security_id;
-        const jobId = kwargs.job_id;
+        const securityId = kwargs['security-id'];
+        const jobId = kwargs['job-id'];
         const text = kwargs.text;
         if (process.env.OPENCLI_VERBOSE) {
             console.error(`[opencli:boss] Greeting candidate ${uid}...`);

package/dist/clis/boss/search.js

@@ -69,7 +69,7 @@ cli({
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'query', required: true, help: 'Search keyword (e.g. AI agent, 前端)' },
+        { name: 'query', required: true, positional: true, help: 'Search keyword (e.g. AI agent, 前端)' },
         { name: 'city', default: '北京', help: 'City name or code (e.g. 杭州, 上海, 101010100)' },
         { name: 'experience', default: '', help: 'Experience: 应届/1年以内/1-3年/3-5年/5-10年/10年以上' },
         { name: 'degree', default: '', help: 'Degree: 大专/本科/硕士/博士' },

package/dist/clis/boss/send.js

@@ -14,7 +14,7 @@ cli({
     browser: true,
     args: [
         { name: 'uid', required: true, help: 'Encrypted UID of the candidate (from chatlist)' },
-        { name: 'text', required: true, help: 'Message text to send' },
+        { name: 'text', required: true, positional: true, help: 'Message text to send' },
     ],
     columns: ['status', 'detail'],
     func: async (page, kwargs) => {

package/dist/clis/boss/stats.js

@@ -15,13 +15,13 @@ cli({
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'job_id', default: '', help: 'Encrypted job ID (show all if empty)' },
+        { name: 'job-id', default: '', help: 'Encrypted job ID (show all if empty)' },
     ],
     columns: ['job_name', 'salary', 'city', 'status', 'total_chats', 'encrypt_job_id'],
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Browser page required');
-        const filterJobId = kwargs.job_id || '';
+        const filterJobId = kwargs['job-id'] || '';
         if (process.env.OPENCLI_VERBOSE) {
             console.error('[opencli:boss] Fetching job statistics...');
         }

package/dist/clis/chaoxing/assignments.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { getCourses, initSession, enterCourse, getTabIframeUrl, parseAssignmentsFromDom, sleep, } from '../../chaoxing.js';
+import { getCourses, initSession, enterCourse, getTabIframeUrl, parseAssignmentsFromDom, sleep, } from './utils.js';
 cli({
     site: 'chaoxing',
     name: 'assignments',

package/dist/clis/chaoxing/exams.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
-import { getCourses, initSession, enterCourse, getTabIframeUrl, parseExamsFromDom, sleep, } from '../../chaoxing.js';
+import { getCourses, initSession, enterCourse, getTabIframeUrl, parseExamsFromDom, sleep, } from './utils.js';
 cli({
     site: 'chaoxing',
     name: 'exams',

package/dist/{chaoxing.d.ts → clis/chaoxing/utils.d.ts}

@@ -5,7 +5,7 @@
  * Chaoxing has no flat "list all assignments" API; data is behind session-gated
  * course pages loaded as iframes.
  */
-import type { IPage } from './types.js';
+import type { IPage } from '../../types.js';
 /** Sleep for given milliseconds (anti-scraping delay). */
 export declare function sleep(ms: number): Promise<void>;
 /** Execute a credentialed fetch in the browser context, returning JSON or text. */

package/dist/{chaoxing.js → clis/chaoxing/utils.js}

@@ -85,7 +85,6 @@ export async function getCourses(page) {
 /** Navigate to the interaction page to establish a Chaoxing session. */
 export async function initSession(page) {
     await page.goto('https://mooc2-ans.chaoxing.com/mooc2-ans/visit/interaction');
-    await page.wait(3);
 }
 /**
  * Enter a course via stucoursemiddle redirect (establishes course session + enc).
@@ -95,7 +94,6 @@ export async function enterCourse(page, course) {
     const url = `https://mooc1.chaoxing.com/visit/stucoursemiddle` +
         `?courseid=${course.courseId}&clazzid=${course.classId}&cpi=${course.cpi}&ismooc2=1&v=2`;
     await page.goto(url);
-    await page.wait(3);
 }
 /**
  * On the course page, click a tab (作业 / 考试) and return the iframe src

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

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

package/dist/{chaoxing.test.js → clis/chaoxing/utils.test.js}

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { formatTimestamp, workStatusLabel } from './chaoxing.js';
+import { formatTimestamp, workStatusLabel } from './utils.js';
 function localDatePrefixFromMillis(ts) {
     const d = new Date(ts);
     const yyyy = d.getFullYear();