@jackwener/opencli 1.7.11 → 1.7.13

package/clis/boss/recommend.js

@@ -6,6 +6,7 @@ import { requirePage, navigateToChat, bossFetch, fetchRecommendList, verbose } f
 cli({
     site: 'boss',
     name: 'recommend',
+    access: 'read',
     description: 'BOSS直聘查看推荐候选人（新招呼列表）',
     domain: 'www.zhipin.com',
     strategy: Strategy.COOKIE,

package/clis/boss/resume.js

@@ -14,6 +14,7 @@ import { requirePage, navigateToChat, findFriendByUid, clickCandidateInList } fr
 cli({
     site: 'boss',
     name: 'resume',
+    access: 'read',
     description: 'BOSS直聘查看候选人简历（招聘端）',
     domain: 'www.zhipin.com',
     strategy: Strategy.COOKIE,

package/clis/boss/search.js

@@ -94,6 +94,7 @@ function formatBossOnline(value) {
 cli({
     site: 'boss',
     name: 'search',
+    access: 'read',
     description: 'BOSS直聘搜索职位（不带关键词时返回为你推荐职位）',
     domain: 'www.zhipin.com',
     strategy: Strategy.COOKIE,

package/clis/boss/send.js

@@ -10,6 +10,7 @@ import { EmptyResultError, selectorError } from '@jackwener/opencli/errors';
 cli({
     site: 'boss',
     name: 'send',
+    access: 'write',
     description: 'BOSS直聘发送聊天消息',
     domain: 'www.zhipin.com',
     strategy: Strategy.COOKIE,

package/clis/boss/stats.js

@@ -6,6 +6,7 @@ import { requirePage, navigateToChat, bossFetch, fetchFriendList, verbose } from
 cli({
     site: 'boss',
     name: 'stats',
+    access: 'read',
     description: 'BOSS直聘职位数据统计',
     domain: 'www.zhipin.com',
     strategy: Strategy.COOKIE,

package/clis/chaoxing/assignments.js

@@ -4,10 +4,10 @@ import { getCourses, initSession, enterCourse, getTabIframeUrl, parseAssignments
 cli({
     site: 'chaoxing',
     name: 'assignments',
+    access: 'read',
     description: '学习通作业列表',
     domain: 'mooc2-ans.chaoxing.com',
     strategy: Strategy.COOKIE,
-    timeoutSeconds: 90,
     args: [
         { name: 'course', type: 'string', help: '按课程名过滤（模糊匹配）' },
         {
@@ -18,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

@@ -3,10 +3,10 @@ import { getCourses, initSession, enterCourse, getTabIframeUrl, parseExamsFromDo
 cli({
     site: 'chaoxing',
     name: 'exams',
+    access: 'read',
     description: '学习通考试列表',
     domain: 'mooc2-ans.chaoxing.com',
     strategy: Strategy.COOKIE,
-    timeoutSeconds: 90,
     args: [
         { name: 'course', type: 'string', help: '按课程名过滤（模糊匹配）' },
         {
@@ -17,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;
@@ -50,17 +44,19 @@ async function currentChatGPTLink(page) {
 export const imageCommand = cli({
     site: 'chatgpt',
     name: 'image',
+    access: 'write',
     description: 'Generate images with ChatGPT web and save them locally',
     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) => {
@@ -68,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 });
@@ -78,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,
+        }];
+    },
+});