@jackwener/opencli 0.9.5 → 0.9.6

package/dist/clis/codex/screenshot.js

@@ -0,0 +1,27 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+export const screenshotCommand = cli({
+    site: 'codex',
+    name: 'screenshot',
+    description: 'Capture a snapshot of the current Codex window (DOM + Accessibility tree)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'output', required: false, positional: true, help: 'Output file path (default: /tmp/codex-snapshot.txt)' },
+    ],
+    columns: ['Status', 'File'],
+    func: async (page, kwargs) => {
+        const outputPath = kwargs.output || '/tmp/codex-snapshot.txt';
+        const snap = await page.snapshot({ compact: true });
+        const html = await page.evaluate('document.documentElement.outerHTML');
+        const htmlPath = outputPath.replace(/\.\w+$/, '') + '-dom.html';
+        const snapPath = outputPath.replace(/\.\w+$/, '') + '-a11y.txt';
+        fs.writeFileSync(htmlPath, html);
+        fs.writeFileSync(snapPath, typeof snap === 'string' ? snap : JSON.stringify(snap, null, 2));
+        return [
+            { Status: 'Success', File: htmlPath },
+            { Status: 'Success', File: snapPath },
+        ];
+    },
+});

package/dist/clis/codex/send.js

@@ -10,16 +10,13 @@ export const sendCommand = cli({
     columns: ['Status', 'InjectedText'],
     func: async (page, kwargs) => {
         const textToInsert = kwargs.text;
-        // We use evaluate to inject text bypassing complex nested shadow roots or contenteditables
         await page.evaluate(`
       (function(text) {
-        // Attempt 1: Look for standard textarea/composer input
         let composer = document.querySelector('textarea, [contenteditable="true"]');
         
-        // Basic heuristic: prioritize elements that are deeply nested, visible, and have 'composer' or 'input' classes
         const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
         if (editables.length > 0) {
-           composer = editables[editables.length - 1]; // Often the active input is appended near the end
+           composer = editables[editables.length - 1];
         }
 
         if (!composer) {
@@ -27,11 +24,11 @@ export const sendCommand = cli({
         }
 
         composer.focus();
-        
-        // This handles Lexical/ProseMirror/Monaco rich-text editors effectively by mimicking human paste/type deeply.
         document.execCommand('insertText', false, text);
       })(${JSON.stringify(textToInsert)})
     `);
+        // Wait for the UI to register the input
+        await page.wait(0.5);
         // Simulate Enter key to submit
         await page.pressKey('Enter');
         return [

package/dist/clis/codex/status.js

@@ -4,8 +4,9 @@ export const statusCommand = cli({
     name: 'status',
     description: 'Check active CDP connection to OpenAI Codex App',
     domain: 'localhost',
-    strategy: Strategy.UI, // Interactive UI manipulation
+    strategy: Strategy.UI,
     browser: true,
+    args: [],
     columns: ['Status', 'Url', 'Title'],
     func: async (page) => {
         const url = await page.evaluate('window.location.href');

package/dist/clis/cursor/ask.d.ts

@@ -0,0 +1 @@
+export declare const askCommand: import("../../registry.js").CliCommand;

package/dist/clis/cursor/ask.js

@@ -0,0 +1,69 @@
+import { cli, Strategy } from '../../registry.js';
+export const askCommand = cli({
+    site: 'cursor',
+    name: 'ask',
+    description: 'Send a prompt and wait for the AI response (send + wait + read)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+        { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        const timeout = parseInt(kwargs.timeout, 10) || 30;
+        // Count existing messages before sending
+        const beforeCount = await page.evaluate(`
+      document.querySelectorAll('[data-message-role]').length
+    `);
+        // Inject text into the active editor and submit
+        const injected = await page.evaluate(`(function(text) {
+        let editor = document.querySelector('.aislash-editor-input, [data-lexical-editor="true"], [contenteditable="true"]');
+        if (!editor) return false;
+        editor.focus();
+        document.execCommand('insertText', false, text);
+        return true;
+      })(${JSON.stringify(text)})`);
+        if (!injected)
+            throw new Error('Could not find input element.');
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        // Poll until a new assistant message appears or timeout
+        const pollInterval = 2; // seconds
+        const maxPolls = Math.ceil(timeout / pollInterval);
+        let response = '';
+        for (let i = 0; i < maxPolls; i++) {
+            await page.wait(pollInterval);
+            const result = await page.evaluate(`
+        (function(prevCount) {
+          const msgs = document.querySelectorAll('[data-message-role]');
+          if (msgs.length <= prevCount) return null;
+          
+          const lastMsg = msgs[msgs.length - 1];
+          const role = lastMsg.getAttribute('data-message-role');
+          if (role === 'human') return null; // Still waiting for assistant
+          
+          const root = lastMsg.querySelector('.markdown-root');
+          const text = root ? root.innerText : lastMsg.innerText;
+          return text ? text.trim() : null;
+        })(${beforeCount})
+      `);
+            if (result) {
+                response = result;
+                break;
+            }
+        }
+        if (!response) {
+            return [
+                { Role: 'User', Text: text },
+                { Role: 'System', Text: `No response received within ${timeout}s. The AI may still be generating.` },
+            ];
+        }
+        return [
+            { Role: 'User', Text: text },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});

package/dist/clis/cursor/composer.js

@@ -10,33 +10,16 @@ export const composerCommand = cli({
     columns: ['Status', 'InjectedText'],
     func: async (page, kwargs) => {
         const textToInsert = kwargs.text;
-        const injected = await page.evaluate(`(async function() {
-        let isComposerVisible = document.querySelector('.composer-bar') !== null || document.querySelector('#composer-toolbar-section') !== null;
-        return isComposerVisible;
-      })()`);
-        if (!injected) {
-            await page.pressKey('Meta+I');
-            await page.wait(1.0);
-        }
-        else {
-            // Just focus it if it's open but unfocused (we can't easily know if it's focused without triggering something)
-            await page.pressKey('Meta+I');
-            await page.wait(0.2);
-            const isStillVisible = await page.evaluate('document.querySelector(".composer-bar") !== null');
-            if (!isStillVisible) {
-                await page.pressKey('Meta+I'); // Re-open
-                await page.wait(0.5);
-            }
-        }
+        // Open/Focus Composer via shortcut — always works regardless of current state
+        await page.pressKey('Meta+I');
+        await page.wait(1);
         const typed = await page.evaluate(`(function(text) {
-        let composer = document.querySelector('.composer-bar [data-lexical-editor="true"], [id*="composer"] [contenteditable="true"], .aislash-editor-input');
-        
-        if (!composer) {
-            composer = document.activeElement;
-            if (!composer || !composer.isContentEditable) {
-                return false;
-            }
+        let composer = document.activeElement;
+        if (!composer || !composer.isContentEditable) {
+            composer = document.querySelector('.composer-bar [data-lexical-editor="true"], [id*="composer"] [contenteditable="true"], .aislash-editor-input');
         }
+        
+        if (!composer) return false;
 
         composer.focus();
         document.execCommand('insertText', false, text);
@@ -45,14 +28,12 @@ export const composerCommand = cli({
         if (!typed) {
             throw new Error('Could not find Cursor Composer input element after pressing Cmd+I.');
         }
-        // Submit the command. In Cursor Composer, Enter usually submits if it's not a multi-line edit.
-        // Sometimes Cmd+Enter is needed? We'll just submit standard Enter.
         await page.wait(0.5);
         await page.pressKey('Enter');
         await page.wait(1);
         return [
             {
-                Status: 'Success (Composer)',
+                Status: 'Success',
                 InjectedText: textToInsert,
             },
         ];

package/dist/clis/cursor/export.d.ts

@@ -0,0 +1 @@
+export declare const cursorExport: import("../../registry.js").CliCommand;

package/dist/clis/cursor/export.js

@@ -0,0 +1,51 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+function makeExportCommand(site, readSelector) {
+    return cli({
+        site,
+        name: 'export',
+        description: `Export the current ${site} conversation to a Markdown file`,
+        domain: 'localhost',
+        strategy: Strategy.UI,
+        browser: true,
+        args: [
+            { name: 'output', required: false, positional: true, help: `Output file (default: /tmp/${site}-export.md)` },
+        ],
+        columns: ['Status', 'File', 'Messages'],
+        func: async (page, kwargs) => {
+            const outputPath = kwargs.output || `/tmp/${site}-export.md`;
+            const md = await page.evaluate(`
+        (function() {
+          const selectors = ${JSON.stringify(readSelector)}.split(',');
+          let messages = [];
+          
+          for (const sel of selectors) {
+            const nodes = document.querySelectorAll(sel.trim());
+            if (nodes.length > 0) {
+              messages = Array.from(nodes).map(n => n.innerText || n.textContent);
+              break;
+            }
+          }
+
+          if (messages.length === 0) {
+            const main = document.querySelector('main, [role="main"], .messages-list, [role="log"]');
+            if (main) messages = [main.innerText || main.textContent];
+          }
+
+          if (messages.length === 0) messages = [document.body.innerText];
+          
+          return messages.map((m, i) => '## Message ' + (i + 1) + '\\n\\n' + m.trim()).join('\\n\\n---\\n\\n');
+        })()
+      `);
+            fs.writeFileSync(outputPath, `# ${site} Conversation Export\\n\\n` + md);
+            return [
+                {
+                    Status: 'Success',
+                    File: outputPath,
+                    Messages: md.split('## Message').length - 1,
+                },
+            ];
+        },
+    });
+}
+export const cursorExport = makeExportCommand('cursor', '[data-message-role]');

package/dist/clis/cursor/history.d.ts

@@ -0,0 +1 @@
+export declare const historyCommand: import("../../registry.js").CliCommand;

package/dist/clis/cursor/history.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '../../registry.js';
+export const historyCommand = cli({
+    site: 'cursor',
+    name: 'history',
+    description: 'List recent chat sessions from the Cursor sidebar',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Title'],
+    func: async (page) => {
+        const items = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Cursor chat history lives in sidebar items
+        const entries = document.querySelectorAll('.agent-sidebar-list-item, [data-testid="chat-history-item"], .chat-history-item, .tree-item');
+        
+        entries.forEach((item, i) => {
+          const title = (item.textContent || item.innerText || '').trim().substring(0, 100);
+          if (title) results.push({ Index: i + 1, Title: title });
+        });
+        
+        // Fallback: try to find sidebar text items
+        if (results.length === 0) {
+          const sidebar = document.querySelector('.sidebar, [class*="sidebar"], .agent-sidebar, .side-bar-container');
+          if (sidebar) {
+            const links = sidebar.querySelectorAll('a, [role="treeitem"], [role="option"]');
+            links.forEach((link, i) => {
+              const text = (link.textContent || '').trim().substring(0, 100);
+              if (text) results.push({ Index: i + 1, Title: text });
+            });
+          }
+        }
+        
+        return results;
+      })()
+    `);
+        if (items.length === 0) {
+            return [{ Index: 0, Title: 'No chat history found. Open the AI sidebar first.' }];
+        }
+        return items;
+    },
+});

package/dist/clis/cursor/new.js

@@ -6,21 +6,12 @@ export const newCommand = cli({
     domain: 'localhost',
     strategy: Strategy.UI,
     browser: true,
+    args: [],
     columns: ['Status'],
     func: async (page) => {
-        const success = await page.evaluate(`
-      (function() {
-        const newChatButton = document.querySelector('[aria-label="New Chat"], [aria-label="New Chat (⌘N)"], .agent-sidebar-new-agent-button');
-        if (newChatButton) {
-            newChatButton.click();
-            return true;
-        }
-        return false;
-      })()
-    `);
-        if (!success) {
-            throw new Error('Could not find New Chat button in Cursor DOM.');
-        }
+        // Use keyboard shortcut — most robust approach, avoids brittle DOM selectors
+        const isMac = process.platform === 'darwin';
+        await page.pressKey(isMac ? 'Meta+N' : 'Control+N');
         await page.wait(1);
         return [{ Status: 'Success' }];
     },

package/dist/clis/cursor/screenshot.d.ts

@@ -0,0 +1 @@
+export declare const screenshotCursor: import("../../registry.js").CliCommand;

package/dist/clis/cursor/screenshot.js

@@ -0,0 +1,31 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+function makeScreenshotCommand(site) {
+    return cli({
+        site,
+        name: 'screenshot',
+        description: `Capture a snapshot of the current ${site} window (DOM + Accessibility tree)`,
+        domain: 'localhost',
+        strategy: Strategy.UI,
+        browser: true,
+        args: [
+            { name: 'output', required: false, positional: true, help: `Output file path (default: /tmp/${site}-snapshot.txt)` },
+        ],
+        columns: ['Status', 'File'],
+        func: async (page, kwargs) => {
+            const outputPath = kwargs.output || `/tmp/${site}-snapshot.txt`;
+            // Get both the accessibility snapshot and the raw DOM HTML
+            const snap = await page.snapshot({ compact: true });
+            const html = await page.evaluate('document.documentElement.outerHTML');
+            const htmlPath = outputPath.replace(/\.\w+$/, '') + '-dom.html';
+            const snapPath = outputPath.replace(/\.\w+$/, '') + '-a11y.txt';
+            fs.writeFileSync(htmlPath, html);
+            fs.writeFileSync(snapPath, typeof snap === 'string' ? snap : JSON.stringify(snap, null, 2));
+            return [
+                { Status: 'Success', File: htmlPath },
+                { Status: 'Success', File: snapPath },
+            ];
+        },
+    });
+}
+export const screenshotCursor = makeScreenshotCommand('cursor');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jackwener/opencli",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "publishConfig": {
     "access": "public"
   },

package/src/clis/antigravity/README.md

@@ -12,9 +12,8 @@ Start the Antigravity desktop app with the Chrome DevTools `remote-debugging-por
 
 \`\`\`bash
 # Start Antigravity in the background
-/Applications/Antigravity.app/Contents/MacOS/Electron \\
-  --remote-debugging-port=9224 \\
-  --remote-allow-origins="*"
+/Applications/Antigravity.app/Contents/MacOS/Electron \
+  --remote-debugging-port=9224
 \`\`\`
 
 *(Note: Depending on your installation, the executable might be named differently, e.g., \`Antigravity\` instead of \`Electron\`.)*

package/src/clis/antigravity/README.zh-CN.md

@@ -15,9 +15,8 @@ CLI all electron！现在支持把所有 electron 应用 CLI 化，从而组合
 
 \`\`\`bash
 # 在后台启动并驻留
-/Applications/Antigravity.app/Contents/MacOS/Electron \\
-  --remote-debugging-port=9224 \\
-  --remote-allow-origins="*"
+/Applications/Antigravity.app/Contents/MacOS/Electron \
+  --remote-debugging-port=9224
 \`\`\`
 
 *(注意：如果你打包的应用重命名过主构建，可能需要把 `Electron` 换成实际的可执行文件名，如 `Antigravity`)*

package/src/clis/antigravity/SKILL.md

@@ -9,7 +9,7 @@ This skill allows AI agents to control the [Antigravity](https://github.com/chen
 ## Requirements
 The target Electron application MUST be launched with the remote-debugging-port flag:
 \`\`\`bash
-/Applications/Antigravity.app/Contents/MacOS/Electron --remote-debugging-port=9224 --remote-allow-origins="*"
+/Applications/Antigravity.app/Contents/MacOS/Electron --remote-debugging-port=9224
 \`\`\`
 
 The agent must configure the endpoint environment variable locally before invoking standard commands:

package/src/clis/antigravity/model.ts

@@ -10,7 +10,7 @@ export const modelCommand = cli({
   args: [
     { name: 'name', help: 'Target model name (e.g. claude, gemini, o1)', required: true, positional: true }
   ],
-  columns: ['status'],
+  columns: ['Status'],
   func: async (page, kwargs) => {
     const targetName = kwargs.name.toLowerCase();
     
@@ -42,6 +42,6 @@ export const modelCommand = cli({
     `);
     
     await page.wait(0.5);
-    return [{ status: `Model switched to: ${kwargs.name}` }];
+    return [{ Status: `Model switched to: ${kwargs.name}` }];
   },
 });

package/src/clis/antigravity/send.ts

@@ -10,7 +10,7 @@ export const sendCommand = cli({
   args: [
     { name: 'message', help: 'The message text to send', required: true, positional: true }
   ],
-  columns: ['status', 'message'],
+  columns: ['Status', 'Message'],
   func: async (page, kwargs) => {
     const text = kwargs.message;
 
@@ -35,6 +35,6 @@ export const sendCommand = cli({
     // Press Enter to submit the message
     await page.pressKey('Enter');
     
-    return [{ status: 'Sent successfully', message: text }];
+    return [{ Status: 'Sent successfully', Message: text }];
   },
 });

package/src/clis/chatgpt/README.md

@@ -1,35 +1,44 @@
 # ChatGPT Desktop Adapter for OpenCLI
 
-Control the **ChatGPT macOS Desktop App** directly from the terminal via native AppleScript automation. Unlike Electron-based apps (Antigravity, Codex, Cursor), ChatGPT Desktop is a native macOS application — OpenCLI drives it using `osascript` and System Events.
+Control the **ChatGPT macOS Desktop App** directly from the terminal. OpenCLI supports two automation approaches for ChatGPT.
 
-## Prerequisites
+## Approach 1: AppleScript (Default, No Setup)
 
+The current built-in commands use native AppleScript automation — no extra launch flags needed.
+
+### Prerequisites
 1. Install the official [ChatGPT Desktop App](https://openai.com/chatgpt/mac/) from OpenAI.
 2. Grant **Accessibility permissions** to your terminal app (Terminal / iTerm / Warp) in **System Settings → Privacy & Security → Accessibility**. This is required for System Events keystroke simulation.
 
-## Setup
-
-No extra environment variables needed — the adapter uses `osascript` directly.
-
-## Commands
-
-### Diagnostics
+### Commands
 - `opencli chatgpt status`: Check if the ChatGPT app is currently running.
-
-### Chat Manipulation
 - `opencli chatgpt new`: Activate ChatGPT and press `Cmd+N` to start a new conversation.
 - `opencli chatgpt send "message"`: Copy your message to clipboard, activate ChatGPT, paste, and submit.
 - `opencli chatgpt read`: Copy the last AI response via `Cmd+Shift+C` and return it as text.
 
+## Approach 2: CDP (Advanced, Electron Debug Mode)
+
+ChatGPT Desktop is also an Electron app and can be launched with a remote debugging port for deeper automation via CDP:
+
+```bash
+/Applications/ChatGPT.app/Contents/MacOS/ChatGPT \
+  --remote-debugging-port=9224
+```
+
+Then set the endpoint:
+```bash
+export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
+```
+
+> **Note**: The CDP approach enables future advanced commands like DOM inspection, model switching, and code extraction — similar to the Cursor and Codex adapters.
+
 ## How It Works
 
-Unlike CDP-based adapters, this adapter:
-- Uses `osascript` to send AppleScript commands to System Events
-- Leverages `pbcopy`/`pbpaste` for clipboard-based text transfer
-- Requires no remote debugging port — works with the stock app
+- **AppleScript mode**: Uses `osascript` and `pbcopy`/`pbpaste` for clipboard-based text transfer. No remote debugging port needed.
+- **CDP mode**: Connects via Playwright to the Electron renderer process for direct DOM manipulation.
 
 ## Limitations
 
 - macOS only (AppleScript dependency)
-- Requires Accessibility permissions for keystroke simulation
+- AppleScript mode requires Accessibility permissions
 - `read` command copies the last response — earlier messages need manual scroll

package/src/clis/chatgpt/README.zh-CN.md

@@ -1,35 +1,44 @@
 # ChatGPT 桌面端适配器
 
-通过原生 AppleScript 自动化，在终端中直接控制 **ChatGPT macOS 桌面应用**。与基于 Electron 的应用（Antigravity、Codex、Cursor）不同，ChatGPT Desktop 是原生 macOS 应用 — OpenCLI 使用 `osascript` 和 System Events 来驱动它。
+在终端中直接控制 **ChatGPT macOS 桌面应用**。OpenCLI 支持两种自动化方式。
 
-## 前置条件
+## 方式一：AppleScript（默认，无需配置）
 
-1. 安装官方 [ChatGPT Desktop App](https://openai.com/chatgpt/mac/)。
-2. 在 **系统设置 → 隐私与安全性 → 辅助功能** 中为终端应用（Terminal / iTerm / Warp）授予 **辅助功能权限**。这是 System Events 按键模拟所必需的。
-
-## 配置
-
-无需额外环境变量 — 适配器直接使用 `osascript`。
+内置命令使用原生 AppleScript 自动化，无需额外启动参数。
 
-## 命令
+### 前置条件
+1. 安装官方 [ChatGPT Desktop App](https://openai.com/chatgpt/mac/)。
+2. 在 **系统设置 → 隐私与安全性 → 辅助功能** 中为终端应用授予权限。
 
-### 诊断
+### 命令
 - `opencli chatgpt status`：检查 ChatGPT 应用是否在运行。
-
-### 对话操作
 - `opencli chatgpt new`：激活 ChatGPT 并按 `Cmd+N` 开始新对话。
 - `opencli chatgpt send "消息"`：将消息复制到剪贴板，激活 ChatGPT，粘贴并提交。
 - `opencli chatgpt read`：通过 `Cmd+Shift+C` 复制最后一条 AI 回复并返回文本。
 
+## 方式二：CDP（高级，Electron 调试模式）
+
+ChatGPT Desktop 同样是 Electron 应用，可以通过远程调试端口启动以实现更深度的自动化：
+
+```bash
+/Applications/ChatGPT.app/Contents/MacOS/ChatGPT \
+  --remote-debugging-port=9224
+```
+
+然后设置环境变量：
+```bash
+export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9224"
+```
+
+> **注意**：CDP 模式支持未来的高级命令（如 DOM 检查、模型切换、代码提取等），与 Cursor 和 Codex 适配器类似。
+
 ## 工作原理
 
-与基于 CDP 的适配器不同，此适配器：
-- 使用 `osascript` 向 System Events 发送 AppleScript 命令
-- 利用 `pbcopy`/`pbpaste` 进行基于剪贴板的文本传输
-- 无需远程调试端口 — 直接与原生应用交互
+- **AppleScript 模式**：使用 `osascript` 和 `pbcopy`/`pbpaste` 进行剪贴板文本传输，无需远程调试端口。
+- **CDP 模式**：通过 Playwright 连接到 Electron 渲染进程，直接操作 DOM。
 
 ## 限制
 
 - 仅支持 macOS（AppleScript 依赖）
-- 需要辅助功能权限以模拟按键
-- `read` 命令复制最后一条回复 — 更早的消息需要手动滚动
+- AppleScript 模式需要辅助功能权限
+- `read` 命令复制最后一条回复，更早的消息需手动滚动

package/src/clis/chatgpt/ask.ts

@@ -0,0 +1,77 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const askCommand = cli({
+  site: 'chatgpt',
+  name: 'ask',
+  description: 'Send a prompt and wait for the AI response (send + wait + read)',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'text', required: true, positional: true, help: 'Prompt to send' },
+    { name: 'timeout', required: false, help: 'Max seconds to wait for response (default: 30)', default: '30' },
+  ],
+  columns: ['Role', 'Text'],
+  func: async (page: IPage | null, kwargs: any) => {
+    const text = kwargs.text as string;
+    const timeout = parseInt(kwargs.timeout as string, 10) || 30;
+
+    // Backup clipboard
+    let clipBackup = '';
+    try { clipBackup = execSync('pbpaste', { encoding: 'utf-8' }); } catch {}
+
+    // Send the message
+    spawnSync('pbcopy', { input: text });
+    execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+    execSync("osascript -e 'delay 0.5'");
+
+    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);
+
+    // Clear clipboard marker
+    spawnSync('pbcopy', { input: '__OPENCLI_WAITING__' });
+
+    // Wait for response, then read it
+    const pollInterval = 3;
+    const maxPolls = Math.ceil(timeout / pollInterval);
+    let response = '';
+
+    for (let i = 0; i < maxPolls; i++) {
+      // Wait
+      execSync(`sleep ${pollInterval}`);
+
+      // Try Cmd+Shift+C to copy the latest response
+      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+      execSync("osascript -e 'tell application \"System Events\" to keystroke \"c\" using {command down, shift down}'");
+      execSync("osascript -e 'delay 0.3'");
+
+      const copied = execSync('pbpaste', { encoding: 'utf-8' }).trim();
+      if (copied && copied !== '__OPENCLI_WAITING__' && copied !== text) {
+        response = copied;
+        break;
+      }
+    }
+
+    // Restore clipboard
+    if (clipBackup) spawnSync('pbcopy', { input: clipBackup });
+
+    if (!response) {
+      return [
+        { Role: 'User', Text: text },
+        { Role: 'System', Text: `No response within ${timeout}s. ChatGPT may still be generating.` },
+      ];
+    }
+
+    return [
+      { Role: 'User', Text: text },
+      { Role: 'Assistant', Text: response },
+    ];
+  },
+});