@jackwener/opencli 1.7.12 → 1.7.14

package/clis/bbc/utils.js

@@ -0,0 +1,79 @@
+// Shared helpers for the bbc adapters that hit BBC's public RSS feeds.
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+export const BBC_FEED_BASE = 'https://feeds.bbci.co.uk/news';
+const UA = 'opencli-bbc-adapter (+https://github.com/jackwener/opencli)';
+
+const HTML_ENTITIES = {
+    '&amp;': '&', '&lt;': '<', '&gt;': '>', '&quot;': '"', '&apos;': "'", '&#39;': "'", '&nbsp;': ' ',
+};
+
+export function decodeHtmlEntities(value) {
+    return String(value ?? '')
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
+        .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
+        .replace(/&(amp|lt|gt|quot|apos|#39|nbsp);/g, (m) => HTML_ENTITIES[m] || m);
+}
+
+/** Extract `<tag>…</tag>` (CDATA-aware) from a block. */
+export function extractRssTag(block, tag) {
+    const cdata = block.match(new RegExp(`<${tag}[^>]*>\\s*<!\\[CDATA\\[([\\s\\S]*?)\\]\\]>\\s*<\\/${tag}>`));
+    if (cdata) return cdata[1];
+    const plain = block.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`));
+    return plain ? plain[1] : '';
+}
+
+export function parseRssItems(xml) {
+    const out = [];
+    const re = /<item[^>]*>([\s\S]*?)<\/item>/g;
+    let m;
+    while ((m = re.exec(String(xml || ''))) !== null) {
+        const block = m[1];
+        out.push({
+            title: decodeHtmlEntities(extractRssTag(block, 'title')).trim(),
+            description: decodeHtmlEntities(extractRssTag(block, 'description')).trim(),
+            link: decodeHtmlEntities(extractRssTag(block, 'link')).trim(),
+            pubDate: decodeHtmlEntities(extractRssTag(block, 'pubDate')).trim(),
+            guid: decodeHtmlEntities(extractRssTag(block, 'guid')).trim(),
+        });
+    }
+    return out;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`bbc ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`bbc ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function bbcFetchRss(path, label) {
+    const url = `${BBC_FEED_BASE}/${path}`;
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/rss+xml, application/xml' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that feeds.bbci.co.uk is reachable from this network.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status} (${url})`);
+    }
+    return resp.text();
+}
+
+/** Convert RFC-822 pubDate to ISO `YYYY-MM-DD`; empty string on parse failure. */
+export function pubDateToIso(value) {
+    if (!value) return '';
+    const d = new Date(value);
+    if (Number.isNaN(d.getTime())) return '';
+    return d.toISOString().slice(0, 10);
+}

package/clis/chaoxing/assignments.js

@@ -8,7 +8,6 @@ cli({
     description: '学习通作业列表',
     domain: 'mooc2-ans.chaoxing.com',
     strategy: Strategy.COOKIE,
-    timeoutSeconds: 90,
     args: [
         { name: 'course', type: 'string', help: '按课程名过滤（模糊匹配）' },
         {
@@ -19,6 +18,7 @@ cli({
             help: '按状态过滤',
         },
         { name: 'limit', type: 'int', default: 20, help: '最大返回数量' },
+        { name: 'timeout', type: 'int', required: false, default: 90, help: 'Max seconds for the overall command (default: 90)' },
     ],
     columns: ['rank', 'course', 'title', 'deadline', 'status', 'score'],
     func: async (page, kwargs) => {

package/clis/chaoxing/exams.js

@@ -7,7 +7,6 @@ cli({
     description: '学习通考试列表',
     domain: 'mooc2-ans.chaoxing.com',
     strategy: Strategy.COOKIE,
-    timeoutSeconds: 90,
     args: [
         { name: 'course', type: 'string', help: '按课程名过滤（模糊匹配）' },
         {
@@ -18,6 +17,7 @@ cli({
             help: '按状态过滤',
         },
         { name: 'limit', type: 'int', default: 20, help: '最大返回数量' },
+        { name: 'timeout', type: 'int', required: false, default: 90, help: 'Max seconds for the overall command (default: 90)' },
     ],
     columns: ['rank', 'course', 'title', 'start', 'end', 'status', 'score'],
     func: async (page, kwargs) => {

package/clis/chatgpt/ask.js

@@ -0,0 +1,57 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    CHATGPT_DOMAIN,
+    CHATGPT_URL,
+    ensureChatGPTComposer,
+    ensureOnChatGPT,
+    getBubbleCount,
+    normalizeBooleanFlag,
+    requireNonEmptyPrompt,
+    requirePositiveInt,
+    sendChatGPTMessage,
+    startNewChat,
+    waitForChatGPTResponse,
+} from './utils.js';
+
+export const askCommand = cli({
+    site: 'chatgpt',
+    name: 'ask',
+    access: 'write',
+    description: 'Send a prompt to ChatGPT web and wait for the response',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'timeout', type: 'int', default: 120, help: 'Max seconds to wait for response' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+    ],
+    columns: ['response'],
+    func: async (page, kwargs) => {
+        const prompt = requireNonEmptyPrompt(kwargs.prompt, 'chatgpt ask');
+        const timeout = requirePositiveInt(
+            Number(kwargs.timeout ?? 120),
+            'chatgpt ask --timeout',
+            'Example: opencli chatgpt ask "hello" --timeout 120',
+        );
+
+        if (normalizeBooleanFlag(kwargs.new)) {
+            await startNewChat(page);
+        } else {
+            await ensureOnChatGPT(page);
+        }
+        await page.wait(2);
+        await ensureChatGPTComposer(page, 'ChatGPT ask requires a logged-in ChatGPT session with a visible composer.');
+
+        const baseline = await getBubbleCount(page);
+        const sent = await sendChatGPTMessage(page, prompt);
+        if (!sent) {
+            throw new CommandExecutionError('Failed to send message to ChatGPT', `Open ${CHATGPT_URL} and verify the composer is ready.`);
+        }
+
+        return [{ response: await waitForChatGPTResponse(page, baseline, prompt, timeout) }];
+    },
+});

package/clis/chatgpt/commands.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './ask.js';
+import './send.js';
+import './read.js';
+import './history.js';
+import './detail.js';
+import './new.js';
+import './status.js';
+import './image.js';
+
+describe('chatgpt browser command registration', () => {
+    it('registers the baseline web chat commands with site-level reuse', () => {
+        const expectedAccess = {
+            ask: 'write',
+            send: 'write',
+            read: 'read',
+            history: 'read',
+            detail: 'read',
+            new: 'read',
+            status: 'read',
+            image: 'write',
+        };
+
+        for (const [name, access] of Object.entries(expectedAccess)) {
+            const cmd = getRegistry().get(`chatgpt/${name}`);
+            expect(cmd, `chatgpt/${name}`).toBeDefined();
+            expect(cmd.site).toBe('chatgpt');
+            expect(cmd.domain).toBe('chatgpt.com');
+            expect(cmd.strategy).toBe('cookie');
+            expect(cmd.browser).toBe(true);
+            expect(cmd.browserSession).toEqual({ reuse: 'site' });
+            expect(cmd.navigateBefore).toBe(false);
+            expect(cmd.access).toBe(access);
+        }
+    });
+
+    it('keeps ask timeout as the runtime-visible integer timeout arg', () => {
+        const ask = getRegistry().get('chatgpt/ask');
+        expect(ask.args).toEqual(expect.arrayContaining([
+            expect.objectContaining({ name: 'timeout', type: 'int', default: 120 }),
+            expect.objectContaining({ name: 'new', type: 'boolean', default: false }),
+        ]));
+    });
+});

package/clis/chatgpt/detail.js

@@ -0,0 +1,46 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    CHATGPT_DOMAIN,
+    CHATGPT_URL,
+    ensureChatGPTLogin,
+    getVisibleMessages,
+    messageHtmlToMarkdown,
+    normalizeBooleanFlag,
+    parseChatGPTConversationId,
+} from './utils.js';
+
+export const detailCommand = cli({
+    site: 'chatgpt',
+    name: 'detail',
+    access: 'read',
+    description: 'Open a ChatGPT web conversation by ID and read its messages',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'id', positional: true, required: true, help: 'Conversation ID or full /c/<id> URL' },
+        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
+    ],
+    columns: ['Index', 'Role', 'Text'],
+    func: async (page, kwargs) => {
+        const id = parseChatGPTConversationId(kwargs.id);
+        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
+        await page.goto(`${CHATGPT_URL}/c/${id}`, { settleMs: 2000 });
+        await page.wait(4);
+        await ensureChatGPTLogin(page, 'ChatGPT detail requires a logged-in ChatGPT session.');
+        const messages = await getVisibleMessages(page);
+        if (!messages.length) {
+            throw new EmptyResultError('chatgpt detail', `No visible ChatGPT messages were found for conversation ${id}.`);
+        }
+        return messages.map((message) => ({
+            Index: message.Index,
+            Role: message.Role,
+            Text: wantMarkdown && message.Role === 'Assistant' && message.Html
+                ? (messageHtmlToMarkdown(message.Html) || message.Text)
+                : message.Text,
+        }));
+    },
+});

package/clis/chatgpt/history.js

@@ -0,0 +1,39 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    CHATGPT_DOMAIN,
+    ensureChatGPTLogin,
+    ensureOnChatGPT,
+    getConversationList,
+    requirePositiveInt,
+} from './utils.js';
+
+export const historyCommand = cli({
+    site: 'chatgpt',
+    name: 'history',
+    access: 'read',
+    description: 'List visible ChatGPT web conversation history from the sidebar',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max conversations to show' },
+    ],
+    columns: ['Index', 'Id', 'Title', 'Url'],
+    func: async (page, kwargs) => {
+        const limit = requirePositiveInt(
+            Number(kwargs.limit ?? 20),
+            'chatgpt history --limit',
+            'Example: opencli chatgpt history --limit 20',
+        );
+        await ensureOnChatGPT(page);
+        await ensureChatGPTLogin(page, 'ChatGPT history requires a logged-in ChatGPT session.');
+        const conversations = await getConversationList(page);
+        if (!conversations.length) {
+            throw new EmptyResultError('chatgpt history', 'No ChatGPT conversation links were visible in the sidebar.');
+        }
+        return conversations.slice(0, limit);
+    },
+});

package/clis/chatgpt/image.js

@@ -3,8 +3,8 @@ import * as path from 'node:path';
 import * as fs from 'node:fs';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { saveBase64ToFile } from '@jackwener/opencli/utils';
-import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { getChatGPTVisibleImageUrls, sendChatGPTMessage, waitForChatGPTImages, getChatGPTImageAssets } from './utils.js';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getChatGPTVisibleImageUrls, normalizeBooleanFlag, sendChatGPTMessage, waitForChatGPTImages, getChatGPTImageAssets } from './utils.js';
 
 const CHATGPT_DOMAIN = 'chatgpt.com';
 
@@ -15,12 +15,6 @@ function extFromMime(mime) {
     return '.jpg';
 }
 
-function normalizeBooleanFlag(value) {
-    if (typeof value === 'boolean') return value;
-    const normalized = String(value ?? '').trim().toLowerCase();
-    return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
-}
-
 function displayPath(filePath) {
     const home = os.homedir();
     return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
@@ -55,13 +49,14 @@ export const imageCommand = cli({
     domain: CHATGPT_DOMAIN,
     strategy: Strategy.COOKIE,
     browser: true,
+    browserSession: { reuse: 'site' },
     navigateBefore: false,
     defaultFormat: 'plain',
-    timeoutSeconds: 240,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to ChatGPT' },
         { name: 'op', help: 'Output directory (default: ~/Pictures/chatgpt)' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show ChatGPT link' },
+        { name: 'timeout', type: 'int', required: false, default: 240, help: 'Max seconds for the overall command (default: 240)' },
     ],
     columns: ['status', 'file', 'link'],
     func: async (page, kwargs) => {
@@ -69,7 +64,10 @@ export const imageCommand = cli({
         const outputDir = resolveOutputDir(kwargs.op);
         const skipDownloadRaw = kwargs.sd;
         const skipDownload = skipDownloadRaw === '' || skipDownloadRaw === true || normalizeBooleanFlag(skipDownloadRaw);
-        const timeout = 120;
+        const timeout = kwargs.timeout;
+        if (!Number.isInteger(timeout) || timeout < 1) {
+            throw new ArgumentError('--timeout must be a positive integer (seconds)');
+        }
 
         // Navigate to chatgpt.com/new with full reload to clear React sidebar state
         await page.goto(`https://${CHATGPT_DOMAIN}/new`, { settleMs: 2000 });
@@ -79,7 +77,10 @@ export const imageCommand = cli({
         // Send the image generation prompt - must be explicit
         const sent = await sendChatGPTMessage(page, `Generate an image of: ${prompt}`);
         if (!sent) {
-            return [{ status: '⚠️ send-failed', file: '📁 -', link: `🔗 ${await currentChatGPTLink(page)}` }];
+            throw new CommandExecutionError(
+                'Failed to send image prompt to ChatGPT',
+                `Open ${await currentChatGPTLink(page)} and verify the composer is ready.`,
+            );
         }
 
         // ChatGPT briefly navigates to /c/{id} after sending, then may

package/clis/chatgpt/image.test.js

@@ -12,6 +12,12 @@ const mocks = vi.hoisted(() => ({
 
 vi.mock('./utils.js', () => ({
     getChatGPTVisibleImageUrls: mocks.getChatGPTVisibleImageUrls,
+    normalizeBooleanFlag: (value, fallback = false) => {
+        if (typeof value === 'boolean') return value;
+        if (value == null || value === '') return fallback;
+        const normalized = String(value).trim().toLowerCase();
+        return normalized === 'true' || normalized === '1' || normalized === 'yes' || normalized === 'on';
+    },
     sendChatGPTMessage: mocks.sendChatGPTMessage,
     waitForChatGPTImages: mocks.waitForChatGPTImages,
     getChatGPTImageAssets: mocks.getChatGPTImageAssets,
@@ -63,6 +69,21 @@ describe('chatgpt image output paths', () => {
 });
 
 describe('chatgpt image failure contracts', () => {
+    it('fails fast when the image prompt cannot be sent', async () => {
+        mocks.sendChatGPTMessage.mockResolvedValue(false);
+
+        await expect(imageCommand.func(createPage(), {
+            prompt: 'cat',
+            op: '',
+            sd: false,
+            timeout: 240,
+        })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Failed to send image prompt to ChatGPT'),
+        });
+        expect(mocks.waitForChatGPTImages).not.toHaveBeenCalled();
+    });
+
     it('fails fast when image generation detection finds no new images', async () => {
         mocks.waitForChatGPTImages.mockResolvedValue([]);
 
@@ -70,6 +91,7 @@ describe('chatgpt image failure contracts', () => {
             prompt: 'cat',
             op: '',
             sd: false,
+            timeout: 240,
         })).rejects.toMatchObject({
             code: 'EMPTY_RESULT',
             message: expect.stringContaining('chatgpt image returned no data'),
@@ -84,6 +106,7 @@ describe('chatgpt image failure contracts', () => {
             prompt: 'cat',
             op: '',
             sd: false,
+            timeout: 240,
         })).rejects.toMatchObject({
             code: 'COMMAND_EXEC',
             message: expect.stringContaining('Failed to export generated ChatGPT image assets'),

package/clis/chatgpt/new.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CHATGPT_DOMAIN,
+    ensureChatGPTComposer,
+    startNewChat,
+} from './utils.js';
+
+export const newCommand = cli({
+    site: 'chatgpt',
+    name: 'new',
+    access: 'read',
+    description: 'Start a new ChatGPT web conversation',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        await startNewChat(page);
+        await ensureChatGPTComposer(page, 'ChatGPT new requires a logged-in ChatGPT session with a visible composer.');
+        return [{ Status: 'New chat started' }];
+    },
+});

package/clis/chatgpt/read.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    CHATGPT_DOMAIN,
+    ensureChatGPTLogin,
+    ensureOnChatGPT,
+    getVisibleMessages,
+    messageHtmlToMarkdown,
+    normalizeBooleanFlag,
+} from './utils.js';
+
+export const readCommand = cli({
+    site: 'chatgpt',
+    name: 'read',
+    access: 'read',
+    description: 'Read messages in the current ChatGPT web conversation',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'markdown', type: 'boolean', default: false, help: 'Emit assistant replies as markdown' },
+    ],
+    columns: ['Index', 'Role', 'Text'],
+    func: async (page, kwargs) => {
+        const wantMarkdown = normalizeBooleanFlag(kwargs.markdown, false);
+        await ensureOnChatGPT(page);
+        await page.wait(2);
+        await ensureChatGPTLogin(page, 'ChatGPT read requires a logged-in ChatGPT session.');
+        const messages = await getVisibleMessages(page);
+        if (!messages.length) {
+            throw new EmptyResultError('chatgpt read', 'No visible ChatGPT messages were found in the current conversation.');
+        }
+        return messages.map((message) => ({
+            Index: message.Index,
+            Role: message.Role,
+            Text: wantMarkdown && message.Role === 'Assistant' && message.Html
+                ? (messageHtmlToMarkdown(message.Html) || message.Text)
+                : message.Text,
+        }));
+    },
+});

package/clis/chatgpt/send.js

@@ -0,0 +1,46 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import {
+    CHATGPT_DOMAIN,
+    CHATGPT_URL,
+    ensureChatGPTComposer,
+    ensureOnChatGPT,
+    normalizeBooleanFlag,
+    requireNonEmptyPrompt,
+    sendChatGPTMessage,
+    startNewChat,
+} from './utils.js';
+
+export const sendCommand = cli({
+    site: 'chatgpt',
+    name: 'send',
+    access: 'write',
+    description: 'Send a prompt to ChatGPT web without waiting for the response',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [
+        { name: 'prompt', positional: true, required: true, help: 'Prompt to send' },
+        { name: 'new', type: 'boolean', default: false, help: 'Start a new chat before sending' },
+    ],
+    columns: ['Status', 'InjectedText'],
+    func: async (page, kwargs) => {
+        const prompt = requireNonEmptyPrompt(kwargs.prompt, 'chatgpt send');
+
+        if (normalizeBooleanFlag(kwargs.new)) {
+            await startNewChat(page);
+        } else {
+            await ensureOnChatGPT(page);
+        }
+        await page.wait(2);
+        await ensureChatGPTComposer(page, 'ChatGPT send requires a logged-in ChatGPT session with a visible composer.');
+
+        const sent = await sendChatGPTMessage(page, prompt);
+        if (!sent) {
+            throw new CommandExecutionError('Failed to send message to ChatGPT', `Open ${CHATGPT_URL} and verify the composer is ready.`);
+        }
+        return [{ Status: 'Success', InjectedText: prompt }];
+    },
+});

package/clis/chatgpt/status.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    CHATGPT_DOMAIN,
+    ensureOnChatGPT,
+    getPageState,
+} from './utils.js';
+
+export const statusCommand = cli({
+    site: 'chatgpt',
+    name: 'status',
+    access: 'read',
+    description: 'Check ChatGPT web page availability and login state',
+    domain: CHATGPT_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    browserSession: { reuse: 'site' },
+    navigateBefore: false,
+    args: [],
+    columns: ['Status', 'Login', 'Url'],
+    func: async (page) => {
+        await ensureOnChatGPT(page);
+        const state = await getPageState(page);
+        return [{
+            Status: state.hasComposer ? 'Connected' : 'Page not ready',
+            Login: state.isLoggedIn && !state.hasLoginGate ? 'Yes' : 'No',
+            Url: state.url,
+        }];
+    },
+});