@jackwener/opencli 1.7.7 → 1.7.9

package/clis/boss/search.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import { __test__ } from './search.js';
+import './search.js';
+
+function createPageMock(response) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue(response),
+    };
+}
+
+describe('boss search', () => {
+    const command = getRegistry().get('boss/search');
+
+    it('keeps legacy 在校/应届 experience input compatible', () => {
+        expect(__test__.resolveMap('在校/应届', __test__.EXP_MAP)).toBe('108');
+        expect(__test__.resolveMap('应届', __test__.EXP_MAP)).toBe('102');
+    });
+
+    it('fails fast on invalid jobType values', async () => {
+        expect(() => __test__.resolveJobType('外包')).toThrow(ArgumentError);
+    });
+
+    it('accepts supported jobType labels and raw codes', () => {
+        expect(__test__.resolveJobType('全职')).toBe('1901');
+        expect(__test__.resolveJobType('实习')).toBe('1902');
+        expect(__test__.resolveJobType('兼职')).toBe('1903');
+        expect(__test__.resolveJobType('1902')).toBe('1902');
+    });
+
+    it('keeps empty query empty and sends jobType filter to the API', async () => {
+        const page = createPageMock({
+            code: 0,
+            zpData: {
+                hasMore: false,
+                jobList: [
+                    {
+                        encryptJobId: 'abc',
+                        securityId: 'sec',
+                        jobName: '前端开发实习生',
+                        salaryDesc: '150-200/天',
+                        brandName: 'OpenCLI',
+                        cityName: '北京',
+                        areaDistrict: '海淀区',
+                        businessDistrict: '',
+                        jobExperience: '在校/应届',
+                        jobDegree: '本科',
+                        skills: ['JavaScript'],
+                        bossName: '张三',
+                        bossTitle: '技术负责人',
+                        bossOnline: false,
+                    },
+                ],
+            },
+        });
+
+        const rows = await command.func(page, {
+            query: undefined,
+            city: '北京',
+            jobType: '实习',
+            limit: 1,
+            page: 1,
+        });
+
+        expect(page.goto).toHaveBeenCalledWith('https://www.zhipin.com/web/geek/job?query=&city=101010100');
+        const fetchScript = page.evaluate.mock.calls.at(-1)[0];
+        expect(fetchScript).toContain('query=');
+        expect(fetchScript).not.toContain('query=undefined');
+        expect(fetchScript).toContain('jobType=1902');
+        expect(rows[0]).toMatchObject({
+            name: '前端开发实习生',
+            bossOnline: 'N',
+        });
+    });
+});

package/clis/boss/send.js

@@ -6,7 +6,7 @@
  */
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { requirePage, navigateToChat, findFriendByUid, clickCandidateInList, typeAndSendMessage, } from './utils.js';
-import { EmptyResultError, SelectorError } from '@jackwener/opencli/errors';
+import { EmptyResultError, selectorError } from '@jackwener/opencli/errors';
 cli({
     site: 'boss',
     name: 'send',
@@ -30,12 +30,12 @@ cli({
         const friendName = friend.name || '候选人';
         const clicked = await clickCandidateInList(page, numericUid);
         if (!clicked) {
-            throw new SelectorError('聊天列表中的用户', '请确认聊天列表中有此人');
+            throw selectorError('聊天列表中的用户', '请确认聊天列表中有此人');
         }
         await page.wait({ time: 2 });
         const sent = await typeAndSendMessage(page, kwargs.text);
         if (!sent) {
-            throw new SelectorError('消息输入框', '聊天页面 UI 可能已改变');
+            throw selectorError('消息输入框', '聊天页面 UI 可能已改变');
         }
         await page.wait({ time: 1 });
         return [{ status: '✅ 发送成功', detail: `已向 ${friendName} 发送: ${kwargs.text}` }];

package/clis/chatgpt/image.js

@@ -1,7 +1,9 @@
 import * as os from 'node:os';
 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';
 
 const CHATGPT_DOMAIN = 'chatgpt.com';
@@ -24,6 +26,22 @@ function displayPath(filePath) {
     return filePath.startsWith(home) ? `~${filePath.slice(home.length)}` : filePath;
 }
 
+export function resolveOutputDir(value) {
+    const raw = String(value || '').trim();
+    if (!raw) return path.join(os.homedir(), 'Pictures', 'chatgpt');
+    if (raw === '~') return os.homedir();
+    if (raw.startsWith('~/')) return path.join(os.homedir(), raw.slice(2));
+    return path.resolve(raw);
+}
+
+export function nextAvailablePath(dir, baseName, ext, existsSync = fs.existsSync) {
+    let candidate = path.join(dir, `${baseName}${ext}`);
+    for (let index = 1; existsSync(candidate); index += 1) {
+        candidate = path.join(dir, `${baseName}_${index}${ext}`);
+    }
+    return candidate;
+}
+
 async function currentChatGPTLink(page) {
     const url = await page.evaluate('window.location.href').catch(() => '');
     return typeof url === 'string' && url ? url : 'https://chatgpt.com';
@@ -41,13 +59,13 @@ export const imageCommand = cli({
     timeoutSeconds: 240,
     args: [
         { name: 'prompt', positional: true, required: true, help: 'Image prompt to send to ChatGPT' },
-        { name: 'op', default: '~/Pictures/chatgpt', help: 'Output directory' },
+        { name: 'op', help: 'Output directory (default: ~/Pictures/chatgpt)' },
         { name: 'sd', type: 'boolean', default: false, help: 'Skip download shorthand; only show ChatGPT link' },
     ],
     columns: ['status', 'file', 'link'],
     func: async (page, kwargs) => {
         const prompt = kwargs.prompt;
-        const outputDir = kwargs.op || path.join(os.homedir(), 'Pictures', 'chatgpt');
+        const outputDir = resolveOutputDir(kwargs.op);
         const skipDownloadRaw = kwargs.sd;
         const skipDownload = skipDownloadRaw === '' || skipDownloadRaw === true || normalizeBooleanFlag(skipDownloadRaw);
         const timeout = 120;
@@ -63,12 +81,23 @@ export const imageCommand = cli({
             return [{ status: '⚠️ send-failed', file: '📁 -', link: `🔗 ${await currentChatGPTLink(page)}` }];
         }
 
-        // Wait for response and images
-        const urls = await waitForChatGPTImages(page, beforeUrls, timeout);
-        const link = await currentChatGPTLink(page);
+        // ChatGPT briefly navigates to /c/{id} after sending, then may
+        // redirect back to the home page. Poll until we capture the /c/ URL.
+        let convUrl = '';
+        for (let ci = 0; ci < 10; ci++) {
+            const url = await currentChatGPTLink(page);
+            if (url.includes('/c/')) { convUrl = url; break; }
+            await page.wait(2);
+        }
+        if (!convUrl) {
+            convUrl = await currentChatGPTLink(page);
+        }
+
+        const urls = await waitForChatGPTImages(page, beforeUrls, timeout, convUrl);
+        const link = convUrl;
 
         if (!urls.length) {
-            return [{ status: '⚠️ no-images', file: '📁 -', link: `🔗 ${link}` }];
+            throw new EmptyResultError('chatgpt image', `No generated images were detected before timeout. Open ${link} and verify whether ChatGPT finished generating the image.`);
         }
 
         if (skipDownload) {
@@ -78,7 +107,7 @@ export const imageCommand = cli({
         // Export and save images
         const assets = await getChatGPTImageAssets(page, urls);
         if (!assets.length) {
-            return [{ status: '⚠️ export-failed', file: '📁 -', link: `🔗 ${link}` }];
+            throw new CommandExecutionError('Failed to export generated ChatGPT image assets', `Open ${link} and verify the generated images are visible, then retry.`);
         }
 
         const stamp = Date.now();
@@ -88,7 +117,7 @@ export const imageCommand = cli({
             const base64 = asset.dataUrl.replace(/^data:[^;]+;base64,/, '');
             const suffix = assets.length > 1 ? `_${index + 1}` : '';
             const ext = extFromMime(asset.mimeType);
-            const filePath = path.join(outputDir, `chatgpt_${stamp}${suffix}${ext}`);
+            const filePath = nextAvailablePath(outputDir, `chatgpt_${stamp}${suffix}`, ext);
             await saveBase64ToFile(base64, filePath);
             results.push({ status: '✅ saved', file: `📁 ${displayPath(filePath)}`, link: `🔗 ${link}` });
         }

package/clis/chatgpt/image.test.js

@@ -0,0 +1,92 @@
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+const mocks = vi.hoisted(() => ({
+    getChatGPTVisibleImageUrls: vi.fn(),
+    sendChatGPTMessage: vi.fn(),
+    waitForChatGPTImages: vi.fn(),
+    getChatGPTImageAssets: vi.fn(),
+    saveBase64ToFile: vi.fn(),
+}));
+
+vi.mock('./utils.js', () => ({
+    getChatGPTVisibleImageUrls: mocks.getChatGPTVisibleImageUrls,
+    sendChatGPTMessage: mocks.sendChatGPTMessage,
+    waitForChatGPTImages: mocks.waitForChatGPTImages,
+    getChatGPTImageAssets: mocks.getChatGPTImageAssets,
+}));
+
+vi.mock('@jackwener/opencli/utils', () => ({
+    saveBase64ToFile: mocks.saveBase64ToFile,
+}));
+
+const { imageCommand, nextAvailablePath, resolveOutputDir } = await import('./image.js');
+
+function createPage() {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue('https://chatgpt.com/c/test-conversation'),
+    };
+}
+
+beforeEach(() => {
+    vi.restoreAllMocks();
+    mocks.getChatGPTVisibleImageUrls.mockReset().mockResolvedValue([]);
+    mocks.sendChatGPTMessage.mockReset().mockResolvedValue(true);
+    mocks.waitForChatGPTImages.mockReset().mockResolvedValue(['https://images.example/generated.png']);
+    mocks.getChatGPTImageAssets.mockReset().mockResolvedValue([{
+        url: 'https://images.example/generated.png',
+        dataUrl: 'data:image/png;base64,aGVsbG8=',
+        mimeType: 'image/png',
+    }]);
+    mocks.saveBase64ToFile.mockReset().mockResolvedValue(undefined);
+});
+
+describe('chatgpt image output paths', () => {
+    it('expands the default and explicit home-relative output directories', () => {
+        expect(resolveOutputDir()).toBe(path.join(os.homedir(), 'Pictures', 'chatgpt'));
+        expect(resolveOutputDir('~/tmp/chatgpt-images')).toBe(path.join(os.homedir(), 'tmp', 'chatgpt-images'));
+        expect(resolveOutputDir('~')).toBe(os.homedir());
+    });
+
+    it('generates a non-overwriting file path when a timestamp collision exists', () => {
+        const dir = '/tmp/chatgpt';
+        const taken = new Set([
+            path.join(dir, 'chatgpt_123.png'),
+            path.join(dir, 'chatgpt_123_1.png'),
+        ]);
+
+        expect(nextAvailablePath(dir, 'chatgpt_123', '.png', (file) => taken.has(file))).toBe(path.join(dir, 'chatgpt_123_2.png'));
+    });
+});
+
+describe('chatgpt image failure contracts', () => {
+    it('fails fast when image generation detection finds no new images', async () => {
+        mocks.waitForChatGPTImages.mockResolvedValue([]);
+
+        await expect(imageCommand.func(createPage(), {
+            prompt: 'cat',
+            op: '',
+            sd: false,
+        })).rejects.toMatchObject({
+            code: 'EMPTY_RESULT',
+            message: expect.stringContaining('chatgpt image returned no data'),
+            hint: expect.stringContaining('No generated images were detected'),
+        });
+    });
+
+    it('fails fast when generated image assets cannot be exported', async () => {
+        mocks.getChatGPTImageAssets.mockResolvedValue([]);
+
+        await expect(imageCommand.func(createPage(), {
+            prompt: 'cat',
+            op: '',
+            sd: false,
+        })).rejects.toMatchObject({
+            code: 'COMMAND_EXEC',
+            message: expect.stringContaining('Failed to export generated ChatGPT image assets'),
+        });
+    });
+});

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

@@ -1,7 +1,7 @@
-import { execSync, spawnSync } from 'node:child_process';
+import { execSync } from 'node:child_process';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ConfigError } from '@jackwener/opencli/errors';
-import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating } from './ax.js';
+import { activateChatGPT, getVisibleChatMessages, selectModel, MODEL_CHOICES, isGenerating, sendPrompt } from './ax.js';
 export const askCommand = cli({
     site: 'chatgpt-app',
     name: 'ask',
@@ -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)');
         }
@@ -27,26 +27,10 @@ export const askCommand = cli({
             activateChatGPT();
             selectModel(model);
         }
-        // Backup clipboard
-        let clipBackup = '';
-        try {
-            clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
-        }
-        catch { }
         const messagesBefore = getVisibleChatMessages();
         // Send the message
-        spawnSync('pbcopy', { input: text });
         activateChatGPT();
-        const cmd = "osascript " +
-            "-e 'tell application \"System Events\"' " +
-            "-e 'keystroke \"v\" using command down' " +
-            "-e 'delay 0.2' " +
-            "-e 'keystroke return' " +
-            "-e 'end tell'";
-        execSync(cmd);
-        // Restore clipboard after the prompt is sent.
-        if (clipBackup)
-            spawnSync('pbcopy', { input: clipBackup });
+        sendPrompt(text);
         // Wait for response: poll until ChatGPT stops generating ("Stop generating" button disappears),
         // then read the final response text.
         const pollInterval = 2;

package/clis/chatgpt-app/ax.js

@@ -60,6 +60,125 @@ for list in lists {
 let data = try! JSONSerialization.data(withJSONObject: best, options: [])
 print(String(data: data, encoding: .utf8)!)
 `;
+const AX_SEND_SCRIPT = `
+import Cocoa
+import ApplicationServices
+
+func attr(_ el: AXUIElement, _ name: String) -> AnyObject? {
+    var value: CFTypeRef?
+    guard AXUIElementCopyAttributeValue(el, name as CFString, &value) == .success else { return nil }
+    return value as AnyObject?
+}
+
+func s(_ el: AXUIElement, _ name: String) -> String? {
+    if let v = attr(el, name) as? String { return v }
+    return nil
+}
+
+func isEnabled(_ el: AXUIElement) -> Bool {
+    (attr(el, kAXEnabledAttribute as String) as? Bool) ?? true
+}
+
+func children(_ el: AXUIElement) -> [AXUIElement] {
+    (attr(el, kAXChildrenAttribute as String) as? [AnyObject] ?? []).map { $0 as! AXUIElement }
+}
+
+func collectEditableInputs(_ el: AXUIElement, into out: inout [AXUIElement], depth: Int = 0) {
+    guard depth < 25 else { return }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    if (role == kAXTextAreaRole as String || role == kAXTextFieldRole as String) && isEnabled(el) {
+        out.append(el)
+    }
+    for c in children(el) { collectEditableInputs(c, into: &out, depth: depth + 1) }
+}
+
+func isInput(_ el: AXUIElement) -> Bool {
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    return role == kAXTextAreaRole as String || role == kAXTextFieldRole as String
+}
+
+func focusedInput(_ axApp: AXUIElement) -> AXUIElement? {
+    guard let focused = attr(axApp, kAXFocusedUIElementAttribute as String) as! AXUIElement? else {
+        return nil
+    }
+    return isInput(focused) && isEnabled(focused) ? focused : nil
+}
+
+func findByDescriptions(_ el: AXUIElement, _ targets: [String], depth: Int = 0) -> AXUIElement? {
+    guard depth < 25 else { return nil }
+    let role = s(el, kAXRoleAttribute as String) ?? ""
+    let desc = s(el, kAXDescriptionAttribute as String) ?? ""
+    if role == "AXButton" && targets.contains(desc) && isEnabled(el) { return el }
+    for c in children(el) {
+        if let found = findByDescriptions(c, targets, depth: depth + 1) { return found }
+    }
+    return nil
+}
+
+func press(_ el: AXUIElement) {
+    AXUIElementPerformAction(el, kAXPressAction as CFString)
+}
+
+let args = CommandLine.arguments
+guard args.count > 1 else {
+    fputs("Missing prompt text\\n", stderr)
+    exit(1)
+}
+let text = args[1]
+
+guard let app = NSRunningApplication.runningApplications(withBundleIdentifier: "com.openai.chat").first else {
+    fputs("ChatGPT not running\\n", stderr)
+    exit(1)
+}
+
+let axApp = AXUIElementCreateApplication(app.processIdentifier)
+guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
+    fputs("No focused ChatGPT window\\n", stderr)
+    exit(1)
+}
+
+var inputs: [AXUIElement] = []
+collectEditableInputs(win, into: &inputs)
+guard let input = focusedInput(axApp) ?? inputs.last else {
+    fputs("Could not find editable input area\\n", stderr)
+    exit(1)
+}
+
+guard AXUIElementSetAttributeValue(input, kAXValueAttribute as CFString, text as CFTypeRef) == .success else {
+    fputs("Failed to set input value\\n", stderr)
+    exit(1)
+}
+
+Thread.sleep(forTimeInterval: 0.2)
+
+guard s(input, kAXValueAttribute as String) == text else {
+    fputs("Failed to verify input value after AX set\\n", stderr)
+    exit(1)
+}
+
+guard let sendButton = findByDescriptions(win, ["发送", "傳送", "Send"]) else {
+    fputs("Could not find send button\\n", stderr)
+    exit(1)
+}
+
+press(sendButton)
+
+var submitted = false
+for _ in 0..<15 {
+    Thread.sleep(forTimeInterval: 0.1)
+    if s(input, kAXValueAttribute as String) != text {
+        submitted = true
+        break
+    }
+}
+
+guard submitted else {
+    fputs("Prompt did not leave input after pressing send\\n", stderr)
+    exit(1)
+}
+
+print("Sent")
+`;
 const AX_MODEL_SCRIPT = `
 import Cocoa
 import ApplicationServices
@@ -121,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)
 }
@@ -192,7 +312,8 @@ let axApp = AXUIElementCreateApplication(app.processIdentifier)
 guard let win = attr(axApp, kAXFocusedWindowAttribute as String) as! AXUIElement? else {
     print("false"); exit(0)
 }
-print(hasButton(win, desc: "Stop generating") ? "true" : "false")
+let targets = ["Stop generating", "停止生成"]
+print(targets.contains(where: { hasButton(win, desc: $0) }) ? "true" : "false")
 `;
 const MODEL_MAP = {
     'auto': { desc: 'Auto' },
@@ -221,6 +342,13 @@ export function selectModel(model) {
     }).trim();
     return output;
 }
+export function sendPrompt(text) {
+    return execFileSync('swift', ['-', text], {
+        input: AX_SEND_SCRIPT,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    }).trim();
+}
 export function isGenerating() {
     try {
         const output = execFileSync('swift', ['-'], {
@@ -250,3 +378,8 @@ export function getVisibleChatMessages() {
         .map((item) => item.replace(/[\uFFFC\u200B-\u200D\uFEFF]/g, '').trim())
         .filter((item) => item.length > 0);
 }
+export const __test__ = {
+    AX_SEND_SCRIPT,
+    AX_MODEL_SCRIPT,
+    AX_GENERATING_SCRIPT,
+};