@jackwener/opencli 1.7.8 → 1.7.10

package/clis/chatgpt/utils.js

@@ -7,11 +7,21 @@ export const CHATGPT_DOMAIN = 'chatgpt.com';
 export const CHATGPT_URL = 'https://chatgpt.com';
 
 // Selectors
-const COMPOSER_SELECTOR = '[aria-label="Chat with ChatGPT"]';
+const COMPOSER_SELECTORS = [
+    '[aria-label="Chat with ChatGPT"]',
+    '[placeholder="Ask anything"]',
+    '#prompt-textarea',
+];
 const SEND_BTN_SELECTOR = 'button[aria-label="Send prompt"]';
 
+function isSameChatGPTConversation(currentUrl, expectedUrl) {
+    if (!currentUrl || !expectedUrl) return false;
+    return currentUrl === expectedUrl
+        || currentUrl.startsWith(`${expectedUrl}?`)
+        || currentUrl.startsWith(`${expectedUrl}#`);
+}
+
 function buildComposerLocatorScript() {
-    const selectorsJson = JSON.stringify([COMPOSER_SELECTOR]);
     const markerAttr = 'data-opencli-chatgpt-composer';
     return `
       const isVisible = (el) => {
@@ -33,7 +43,7 @@ function buildComposerLocatorScript() {
         const marked = document.querySelector('[' + markerAttr + '="1"]');
         if (marked instanceof HTMLElement && isVisible(marked)) return marked;
 
-        for (const selector of ${JSON.stringify([COMPOSER_SELECTOR])}) {
+        for (const selector of ${JSON.stringify(COMPOSER_SELECTORS)}) {
           const node = Array.from(document.querySelectorAll(selector)).find(c => c instanceof HTMLElement && isVisible(c));
           if (node instanceof HTMLElement) {
             node.setAttribute(markerAttr, '1');
@@ -89,7 +99,9 @@ export async function sendChatGPTMessage(page, text) {
         // Fallback: use execCommand
         await page.evaluate(`
             (() => {
-                const composer = document.querySelector('[aria-label="Chat with ChatGPT"]');
+                var composer = null;
+                var sels = ${JSON.stringify(COMPOSER_SELECTORS)};
+                for (var si = 0; si < sels.length; si++) { composer = document.querySelector(sels[si]); if (composer) break; }
                 if (!composer) return;
                 composer.focus();
                 document.execCommand('insertText', false, ${JSON.stringify(text)});
@@ -181,7 +193,7 @@ export async function getChatGPTVisibleImageUrls(page) {
 /**
  * Wait for new images to appear after sending a prompt.
  */
-export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds) {
+export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds, convUrl) {
     const beforeSet = new Set(beforeUrls);
     const pollIntervalSeconds = 3;
     const maxPolls = Math.max(1, Math.ceil(timeoutSeconds / pollIntervalSeconds));
@@ -191,10 +203,26 @@ export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds) {
     for (let i = 0; i < maxPolls; i++) {
         await page.wait(i === 0 ? 3 : pollIntervalSeconds);
 
-        // Check if still generating
+        let currentUrl = '';
+        if (convUrl && convUrl.includes('/c/')) {
+            currentUrl = await page.evaluate('window.location.href').catch(() => '');
+            if (currentUrl && !isSameChatGPTConversation(currentUrl, convUrl)) {
+                await page.goto(convUrl);
+                await page.wait(3);
+            }
+        }
+
         const generating = await isGenerating(page);
         if (generating) continue;
 
+        if (convUrl && convUrl.includes('/c/') && i > 0 && i % 5 === 0) {
+            const onConversation = !currentUrl || isSameChatGPTConversation(currentUrl, convUrl);
+            if (onConversation) {
+                await page.goto(convUrl);
+                await page.wait(3);
+            }
+        }
+
         const urls = (await getChatGPTVisibleImageUrls(page)).filter(url => !beforeSet.has(url));
         if (urls.length === 0) continue;
 
@@ -214,6 +242,11 @@ export async function waitForChatGPTImages(page, beforeUrls, timeoutSeconds) {
     return lastUrls;
 }
 
+export const __test__ = {
+    COMPOSER_SELECTORS,
+    isSameChatGPTConversation,
+};
+
 /**
  * Export images by URL: fetch from ChatGPT backend API and convert to base64 data URLs.
  */

package/clis/chatgpt/utils.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest';
+import { __test__, waitForChatGPTImages } from './utils.js';
+
+function createPageMock({ location = '', generating = [], imageUrls = [] } = {}) {
+    let generatingIndex = 0;
+    let imageIndex = 0;
+    return {
+        wait: vi.fn().mockResolvedValue(undefined),
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn((script) => {
+            if (script === 'window.location.href') return Promise.resolve(location);
+            if (script.includes('Stop generating') || script.includes('Thinking')) {
+                const value = generating[Math.min(generatingIndex, generating.length - 1)] ?? false;
+                generatingIndex += 1;
+                return Promise.resolve(value);
+            }
+            if (script.includes("document.querySelectorAll('img')")) {
+                const value = imageUrls[Math.min(imageIndex, imageUrls.length - 1)] ?? [];
+                imageIndex += 1;
+                return Promise.resolve(value);
+            }
+            return Promise.resolve(undefined);
+        }),
+    };
+}
+
+describe('chatgpt image wait contract', () => {
+    it('does not periodically reload the conversation while generation is still active', async () => {
+        const convUrl = 'https://chatgpt.com/c/demo';
+        const page = createPageMock({
+            location: convUrl,
+            generating: [true, true, true, true, true, true],
+        });
+
+        await expect(waitForChatGPTImages(page, [], 18, convUrl)).resolves.toEqual([]);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('jumps back to the captured conversation when the page drifts away', async () => {
+        const convUrl = 'https://chatgpt.com/c/demo';
+        const page = createPageMock({
+            location: 'https://chatgpt.com/',
+            generating: [false],
+            imageUrls: [['https://cdn.openai.com/generated/demo.png']],
+        });
+
+        await expect(waitForChatGPTImages(page, [], 3, convUrl)).resolves.toEqual([
+            'https://cdn.openai.com/generated/demo.png',
+        ]);
+        expect(page.goto).toHaveBeenCalledWith(convUrl);
+    });
+
+    it('treats query and hash variants as the same conversation', () => {
+        expect(__test__.isSameChatGPTConversation(
+            'https://chatgpt.com/c/demo?model=gpt-image-1',
+            'https://chatgpt.com/c/demo',
+        )).toBe(true);
+        expect(__test__.isSameChatGPTConversation(
+            'https://chatgpt.com/c/other',
+            'https://chatgpt.com/c/demo',
+        )).toBe(false);
+    });
+});

package/clis/chatgpt-app/ask.js

@@ -15,7 +15,7 @@ export const askCommand = cli({
         { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
     ],
     columns: ['Role', 'Text'],
-    func: async (page, kwargs) => {
+    func: async (kwargs) => {
         if (process.platform !== 'darwin') {
             throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
         }

package/clis/chatgpt-app/ax.js

@@ -156,7 +156,7 @@ guard s(input, kAXValueAttribute as String) == text else {
     exit(1)
 }
 
-guard let sendButton = findByDescriptions(win, ["发送", "Send"]) else {
+guard let sendButton = findByDescriptions(win, ["发送", "傳送", "Send"]) else {
     fputs("Could not find send button\\n", stderr)
     exit(1)
 }
@@ -240,10 +240,11 @@ let args = CommandLine.arguments
 let target = args.count > 1 ? args[1] : ""
 let needsLegacy = args.count > 2 && args[2] == "legacy"
 
-// Step 1: Click the "Options" button to open the popover (support both English and Chinese UI)
+// Step 1: Click the "Options" button to open the popover (support English, Simplified and Traditional Chinese UI)
 var optionsBtn: AXUIElement? = nil
 if let btn = findByDesc(win, "Options") { optionsBtn = btn }
 else if let btn = findByDesc(win, "选项") { optionsBtn = btn }
+else if let btn = findByDesc(win, "選項") { optionsBtn = btn }
 guard let options = optionsBtn else {
     fputs("Could not find Options button\\n", stderr); exit(1)
 }
@@ -379,5 +380,6 @@ export function getVisibleChatMessages() {
 }
 export const __test__ = {
     AX_SEND_SCRIPT,
+    AX_MODEL_SCRIPT,
     AX_GENERATING_SCRIPT,
 };

package/clis/chatgpt-app/ax.test.js

@@ -13,6 +13,18 @@ describe('chatgpt-app AX send script', () => {
     it('does not report success until the prompt leaves the composer after send', () => {
         expect(__test__.AX_SEND_SCRIPT).toContain('Prompt did not leave input after pressing send');
     });
+
+    it('supports english, zh-CN, and zh-TW send button labels', () => {
+        expect(__test__.AX_SEND_SCRIPT).toContain('["发送", "傳送", "Send"]');
+    });
+});
+
+describe('chatgpt-app AX model script', () => {
+    it('supports english, zh-CN, and zh-TW options button labels', () => {
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "Options")');
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "选项")');
+        expect(__test__.AX_MODEL_SCRIPT).toContain('findByDesc(win, "選項")');
+    });
 });
 
 describe('chatgpt-app generating detection', () => {

package/clis/chatgpt-app/model.js

@@ -12,7 +12,7 @@ export const modelCommand = cli({
         { name: 'model', required: true, positional: true, help: 'Model to switch to', choices: MODEL_CHOICES },
     ],
     columns: ['Status', 'Model'],
-    func: async (page, kwargs) => {
+    func: async (kwargs) => {
         if (process.platform !== 'darwin') {
             throw new ConfigError('ChatGPT Desktop integration requires macOS');
         }

package/clis/chatgpt-app/new.js

@@ -10,7 +10,7 @@ export const newCommand = cli({
     browser: false,
     args: [],
     columns: ['Status'],
-    func: async (page) => {
+    func: async () => {
         if (process.platform !== 'darwin') {
             throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
         }

package/clis/chatgpt-app/read.js

@@ -11,7 +11,7 @@ export const readCommand = cli({
     browser: false,
     args: [],
     columns: ['Role', 'Text'],
-    func: async (page) => {
+    func: async () => {
         if (process.platform !== 'darwin') {
             throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
         }

package/clis/chatgpt-app/send.js

@@ -13,7 +13,7 @@ export const sendCommand = cli({
         { name: 'model', required: false, help: 'Model/mode to use: auto, instant, thinking, 5.2-instant, 5.2-thinking', choices: MODEL_CHOICES },
     ],
     columns: ['Status'],
-    func: async (page, kwargs) => {
+    func: async (kwargs) => {
         const text = kwargs.text;
         const model = kwargs.model;
         try {

package/clis/chatgpt-app/status.js

@@ -10,7 +10,7 @@ export const statusCommand = cli({
     browser: false,
     args: [],
     columns: ['Status'],
-    func: async (page) => {
+    func: async () => {
         if (process.platform !== 'darwin') {
             throw new ConfigError('ChatGPT Desktop integration requires macOS (osascript is not available on this platform)');
         }

package/clis/chatwise/ask.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const askCommand = cli({
     site: 'chatwise',
     name: 'ask',
@@ -43,7 +43,7 @@ export const askCommand = cli({
       })(${JSON.stringify(text)})
     `);
         if (!injected)
-            throw new SelectorError('ChatWise input element');
+            throw selectorError('ChatWise input element');
         await page.wait(0.5);
         await page.pressKey('Enter');
         // Poll for response

package/clis/chatwise/model.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const modelCommand = cli({
     site: 'chatwise',
     name: 'model',
@@ -58,7 +58,7 @@ export const modelCommand = cli({
         })(${JSON.stringify(desiredModel)})
       `);
             if (!opened)
-                throw new SelectorError('ChatWise model selector');
+                throw selectorError('ChatWise model selector');
             await page.wait(0.5);
             // Find and click the target model in the dropdown
             const found = await page.evaluate(`

package/clis/chatwise/send.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { SelectorError } from '@jackwener/opencli/errors';
+import { selectorError } from '@jackwener/opencli/errors';
 export const sendCommand = cli({
     site: 'chatwise',
     name: 'send',
@@ -36,7 +36,7 @@ export const sendCommand = cli({
       })(${JSON.stringify(text)})
     `);
         if (!injected)
-            throw new SelectorError('ChatWise input element');
+            throw selectorError('ChatWise input element');
         await page.wait(0.5);
         await page.pressKey('Enter');
         return [

package/clis/claude/ask.js

@@ -0,0 +1,128 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import {
+    CLAUDE_DOMAIN, CLAUDE_URL, ensureOnClaude, selectModel, setAdaptiveThinking,
+    sendMessage, sendWithFile, getBubbleCount, waitForResponse, parseBoolFlag, withRetry,
+    ensureClaudeComposer, requireNonEmptyPrompt, requirePositiveInt,
+} from './utils.js';
+
+export const askCommand = cli({
+    site: 'claude',
+    name: 'ask',
+    description: 'Send a prompt to Claude and get the response',
+    domain: CLAUDE_DOMAIN,
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    timeoutSeconds: 180,
+    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' },
+        { name: 'model', default: 'sonnet', choices: ['sonnet', 'opus', 'haiku'], help: 'Model to use: sonnet, opus, or haiku' },
+        { name: 'think', type: 'boolean', default: false, help: 'Enable Adaptive thinking' },
+        { name: 'file', help: 'Attach a file (image, PDF, text) with the prompt' },
+    ],
+    columns: ['response'],
+
+    func: async (page, kwargs) => {
+        const prompt = requireNonEmptyPrompt(kwargs.prompt, 'claude ask');
+        const timeoutSeconds = requirePositiveInt(
+            Number(kwargs.timeout ?? 120),
+            'claude ask --timeout',
+            'Example: opencli claude ask "hello" --timeout 120',
+        );
+        const timeoutMs = timeoutSeconds * 1000;
+        const wantThink = parseBoolFlag(kwargs.think);
+
+        if (parseBoolFlag(kwargs.new)) {
+            await page.goto(CLAUDE_URL);
+            await page.wait(3);
+        } else {
+            const navigated = await ensureOnClaude(page);
+            if (navigated) {
+                // Workspace was recycled; try to resume the most recent
+                // conversation instead of starting a new one.
+                await page.evaluate(`(() => {
+                    var link = document.querySelector('a[href*="/chat/"]');
+                    if (link) link.click();
+                })()`);
+                await page.wait(2);
+            }
+        }
+
+        await page.wait(2);
+        await withRetry(() => ensureClaudeComposer(page, 'Claude ask requires a visible composer on the current page.'));
+
+        // Model selector is only available on the new-chat page, not inside
+        // an existing conversation. Skip it when we resumed a prior thread.
+        const currentUrl = await page.evaluate('window.location.href') || '';
+        const inConversation = currentUrl.includes('/chat/');
+        const modelExplicit = kwargs.__opencliOptionSources?.model === 'cli';
+
+        const wantModel = kwargs.model || 'sonnet';
+        if (inConversation && modelExplicit) {
+            throw new ArgumentError(
+                `Cannot switch to ${wantModel} model inside an existing conversation.`,
+                'Re-run with --new to start a fresh chat before selecting a model.',
+            );
+        }
+
+        if (!inConversation) {
+            const modelResult = await withRetry(() => selectModel(page, wantModel));
+            if (!modelResult?.ok) {
+                if (modelResult?.upgrade) {
+                    throw new ArgumentError(
+                        `${wantModel} model requires a paid Claude plan.`,
+                        'Pick --model sonnet or --model haiku, or upgrade your account.',
+                    );
+                }
+                throw new CommandExecutionError(`Could not switch to ${wantModel} model`);
+            }
+            if (modelResult?.toggled) await page.wait(0.5);
+        }
+
+        const thinkResult = await withRetry(() => setAdaptiveThinking(page, wantThink));
+        if (!thinkResult?.ok && wantThink) {
+            throw new CommandExecutionError('Could not enable Adaptive thinking');
+        }
+        if (thinkResult?.toggled) await page.wait(0.5);
+
+        if (kwargs.file) {
+            const baseline = await withRetry(() => getBubbleCount(page));
+            try {
+                const fileResult = await sendWithFile(page, kwargs.file, prompt);
+                if (fileResult && !fileResult.ok) {
+                    throw new CommandExecutionError(fileResult.reason || 'Failed to attach file');
+                }
+            } catch (err) {
+                // SPA navigates after send; "Promise was collected" means send succeeded
+                if (!String(err?.message || err).includes('Promise was collected')) throw err;
+            }
+            await page.wait(3);
+            const result = await waitForResponse(page, baseline, prompt, timeoutMs);
+            if (!result) {
+                throw new EmptyResultError(
+                    'claude ask',
+                    `No Claude response appeared within ${timeoutSeconds}s. Re-run with a higher --timeout if the model is still generating.`,
+                );
+            }
+            return [{ response: result }];
+        }
+
+        const baseline = await withRetry(() => getBubbleCount(page));
+        const sendResult = await withRetry(() => sendMessage(page, prompt));
+        if (!sendResult?.ok) {
+            throw new CommandExecutionError(sendResult?.reason || 'Failed to send message');
+        }
+
+        const result = await waitForResponse(page, baseline, prompt, timeoutMs);
+        if (!result) {
+            throw new EmptyResultError(
+                'claude ask',
+                `No Claude response appeared within ${timeoutSeconds}s. Re-run with a higher --timeout if the model is still generating.`,
+            );
+        }
+        return [{ response: result }];
+    },
+});