@jackwener/opencli 0.9.4 → 0.9.6

package/src/clis/chatgpt/README.md

@@ -0,0 +1,44 @@
+# ChatGPT Desktop Adapter for OpenCLI
+
+Control the **ChatGPT macOS Desktop App** directly from the terminal. OpenCLI supports two automation approaches for ChatGPT.
+
+## 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.
+
+### Commands
+- `opencli chatgpt status`: Check if the ChatGPT app is currently running.
+- `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
+
+- **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)
+- AppleScript mode requires Accessibility permissions
+- `read` command copies the last response — earlier messages need manual scroll

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

@@ -0,0 +1,44 @@
+# ChatGPT 桌面端适配器
+
+在终端中直接控制 **ChatGPT macOS 桌面应用**。OpenCLI 支持两种自动化方式。
+
+## 方式一：AppleScript（默认，无需配置）
+
+内置命令使用原生 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 适配器类似。
+
+## 工作原理
+
+- **AppleScript 模式**：使用 `osascript` 和 `pbcopy`/`pbpaste` 进行剪贴板文本传输，无需远程调试端口。
+- **CDP 模式**：通过 Playwright 连接到 Electron 渲染进程，直接操作 DOM。
+
+## 限制
+
+- 仅支持 macOS（AppleScript 依赖）
+- 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 },
+    ];
+  },
+});

package/src/clis/chatgpt/new.ts

@@ -0,0 +1,24 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const newCommand = cli({
+  site: 'chatgpt',
+  name: 'new',
+  description: 'Open a new chat in ChatGPT Desktop App',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Status'],
+  func: async (page: IPage | null) => {
+    try {
+      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+      execSync("osascript -e 'delay 0.5'");
+      execSync("osascript -e 'tell application \"System Events\" to keystroke \"n\" using command down'");
+      return [{ Status: 'Success' }];
+    } catch (err: any) {
+      return [{ Status: "Error: " + err.message }];
+    }
+  },
+});

package/src/clis/chatgpt/read.ts

@@ -0,0 +1,32 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const readCommand = cli({
+  site: 'chatgpt',
+  name: 'read',
+  description: 'Copy the most recent ChatGPT Desktop App response to clipboard and read it',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Role', 'Text'],
+  func: async (page: IPage | null) => {
+    try {
+      execSync("osascript -e 'tell application \"ChatGPT\" to activate'");
+      execSync("osascript -e 'delay 0.5'");
+      execSync("osascript -e 'tell application \"System Events\" to keystroke \"c\" using {command down, shift down}'");
+      execSync("osascript -e 'delay 0.3'");
+
+      const result = execSync('pbpaste', { encoding: 'utf-8' }).trim();
+      
+      if (!result) {
+        return [{ Role: 'System', Text: 'No text was copied. Is there a response in the chat?' }];
+      }
+
+      return [{ Role: 'Assistant', Text: result }];
+    } catch (err: any) {
+      throw new Error("Failed to read from ChatGPT: " + err.message);
+    }
+  },
+});

package/src/clis/chatgpt/send.ts

@@ -0,0 +1,48 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const sendCommand = cli({
+  site: 'chatgpt',
+  name: 'send',
+  description: 'Send a message to the active ChatGPT Desktop App window',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+  columns: ['Status'],
+  func: async (page: IPage | null, kwargs: any) => {
+    const text = kwargs.text as string;
+    try {
+      // Backup current clipboard content
+      let clipBackup = '';
+      try {
+        clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+      } catch { /* clipboard may be empty */ }
+
+      // Copy text to clipboard
+      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);
+
+      // Restore original clipboard content
+      if (clipBackup) {
+        spawnSync('pbcopy', { input: clipBackup });
+      }
+
+      return [{ Status: 'Success' }];
+    } catch (err: any) {
+      return [{ Status: "Error: " + err.message }];
+    }
+  },
+});

package/src/clis/chatgpt/status.ts

@@ -0,0 +1,22 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const statusCommand = cli({
+  site: 'chatgpt',
+  name: 'status',
+  description: 'Check if ChatGPT Desktop App is running natively on macOS',
+  domain: 'localhost',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [],
+  columns: ['Status'],
+  func: async (page: IPage | null) => {
+    try {
+      const output = execSync("osascript -e 'application \"ChatGPT\" is running'", { encoding: 'utf-8' }).trim();
+      return [{ Status: output === 'true' ? 'Running' : 'Stopped' }];
+    } catch {
+      return [{ Status: 'Error querying application state' }];
+    }
+  },
+});

package/src/clis/codex/README.md

@@ -31,3 +31,4 @@ export OPENCLI_CODEX_CDP_ENDPOINT="http://127.0.0.1:9222"
   - *Pro-tip*: You can trigger internal shortcuts by sending them, e.g., `opencli codex send "/review"` or `opencli codex send "$imagegen draw a cat"`.
 - `opencli codex read`: Extracts the entire current thread history and AI reasoning logs into readable text.
 - `opencli codex extract-diff`: Automatically scrapes any visual Patch chunks and Code Diffs the AI generated inside the review UI.
+- `opencli codex model`: Get the currently active AI model.

package/src/clis/codex/ask.ts

@@ -0,0 +1,77 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const askCommand = cli({
+  site: 'codex',
+  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: 60)', default: '60' },
+  ],
+  columns: ['Role', 'Text'],
+  func: async (page: IPage, kwargs: any) => {
+    const text = kwargs.text as string;
+    const timeout = parseInt(kwargs.timeout as string, 10) || 60;
+
+    // Snapshot the current content length before sending
+    const beforeLen = await page.evaluate(`
+      (function() {
+        const turns = document.querySelectorAll('[data-content-search-turn-key]');
+        return turns.length;
+      })()
+    `);
+
+    // Inject and send
+    await page.evaluate(`
+      (function(text) {
+        const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
+        const composer = editables.length > 0 ? editables[editables.length - 1] : document.querySelector('textarea');
+        if (!composer) throw new Error('Could not find Codex input');
+        composer.focus();
+        document.execCommand('insertText', false, text);
+      })(${JSON.stringify(text)})
+    `);
+    await page.wait(0.5);
+    await page.pressKey('Enter');
+
+    // Poll for new content
+    const pollInterval = 3;
+    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(prevLen) {
+          const turns = document.querySelectorAll('[data-content-search-turn-key]');
+          if (turns.length <= prevLen) return null;
+          const lastTurn = turns[turns.length - 1];
+          const text = lastTurn.innerText || lastTurn.textContent;
+          return text ? text.trim() : null;
+        })(${beforeLen})
+      `);
+
+      if (result) {
+        response = result;
+        break;
+      }
+    }
+
+    if (!response) {
+      return [
+        { Role: 'User', Text: text },
+        { Role: 'System', Text: `No response within ${timeout}s. The agent may still be working.` },
+      ];
+    }
+
+    return [
+      { Role: 'User', Text: text },
+      { Role: 'Assistant', Text: response },
+    ];
+  },
+});

package/src/clis/codex/export.ts

@@ -0,0 +1,42 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const exportCommand = cli({
+  site: 'codex',
+  name: 'export',
+  description: 'Export the current Codex conversation to a Markdown file',
+  domain: 'localhost',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'output', required: false, positional: true, help: 'Output file (default: /tmp/codex-export.md)' },
+  ],
+  columns: ['Status', 'File', 'Messages'],
+  func: async (page: IPage, kwargs: any) => {
+    const outputPath = (kwargs.output as string) || '/tmp/codex-export.md';
+
+    const md = await page.evaluate(`
+      (function() {
+        const turns = document.querySelectorAll('[data-content-search-turn-key]');
+        if (turns.length > 0) {
+          return Array.from(turns).map((t, i) => '## Turn ' + (i + 1) + '\\n\\n' + (t.innerText || t.textContent).trim()).join('\\n\\n---\\n\\n');
+        }
+        
+        const main = document.querySelector('main, [role="main"], [role="log"]');
+        if (main) return main.innerText || main.textContent;
+        return document.body.innerText;
+      })()
+    `);
+
+    fs.writeFileSync(outputPath, '# Codex Conversation Export\\n\\n' + md);
+
+    return [
+      {
+        Status: 'Success',
+        File: outputPath,
+        Messages: md.split('## Turn').length - 1,
+      },
+    ];
+  },
+});

package/src/clis/codex/extract-diff.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
 
 export const extractDiffCommand = cli({
   site: 'codex',

package/src/clis/codex/history.ts

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+export const historyCommand = cli({
+  site: 'codex',
+  name: 'history',
+  description: 'List recent conversation threads in Codex',
+  domain: 'localhost',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [],
+  columns: ['Index', 'Title'],
+  func: async (page: IPage) => {
+    const items = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Codex thread list items
+        const entries = document.querySelectorAll('[data-testid*="thread"], [class*="thread-list"] a, [role="listbox"] [role="option"]');
+        
+        entries.forEach((item, i) => {
+          const title = (item.textContent || item.innerText || '').trim().substring(0, 100);
+          if (title) results.push({ Index: i + 1, Title: title });
+        });
+        
+        // Fallback: sidebar/nav links
+        if (results.length === 0) {
+          const nav = document.querySelector('nav, [role="navigation"], aside');
+          if (nav) {
+            const links = nav.querySelectorAll('a, button');
+            links.forEach((link, i) => {
+              const text = (link.textContent || '').trim().substring(0, 100);
+              if (text && text.length > 3) results.push({ Index: i + 1, Title: text });
+            });
+          }
+        }
+        
+        return results;
+      })()
+    `);
+
+    if (items.length === 0) {
+      return [{ Index: 0, Title: 'No threads found. Try opening the thread list first.' }];
+    }
+
+    return items;
+  },
+});

package/src/clis/codex/read.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
 
 export const readCommand = cli({
   site: 'codex',
@@ -7,31 +8,29 @@ export const readCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
-  columns: ['Thread_Content'],
-  func: async (page) => {
+  args: [],
+  columns: ['Content'],
+  func: async (page: IPage) => {
     const historyText = await page.evaluate(`
       (function() {
-        // Precise Codex selector for chat messages
         const turns = Array.from(document.querySelectorAll('[data-content-search-turn-key]'));
         if (turns.length > 0) {
             return turns.map(t => t.innerText || t.textContent).join('\\n\\n---\\n\\n');
         }
         
-        // Fallback robust scraping heuristic for chat history panes
         const threadContainer = document.querySelector('[role="log"], [data-testid="conversation"], .thread-container, .messages-list, main');
         
         if (threadContainer) {
           return threadContainer.innerText || threadContainer.textContent;
         }
         
-        // If specific containers fail, just dump the whole body's readable text minus the navigation
         return document.body.innerText;
       })()
     `);
 
     return [
       {
-        Thread_Content: historyText,
+        Content: historyText,
       },
     ];
   },

package/src/clis/codex/screenshot.ts

@@ -0,0 +1,33 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: IPage, kwargs: any) => {
+    const outputPath = (kwargs.output as string) || '/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/src/clis/codex/send.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
 
 export const sendCommand = cli({
   site: 'codex',
@@ -9,19 +10,16 @@ export const sendCommand = cli({
   browser: true,
   args: [{ name: 'text', required: true, positional: true, help: 'Text, command (e.g. /review), or skill (e.g. $imagegen)' }],
   columns: ['Status', 'InjectedText'],
-  func: async (page, kwargs) => {
+  func: async (page: IPage, kwargs: any) => {
     const textToInsert = kwargs.text as string;
 
-    // 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) {
@@ -29,12 +27,13 @@ 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');
 

package/src/clis/codex/status.ts

@@ -1,14 +1,16 @@
 import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
 
 export const statusCommand = cli({
   site: 'codex',
   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) => {
+  func: async (page: IPage) => {
     const url = await page.evaluate('window.location.href');
     const title = await page.evaluate('document.title');
 

package/src/clis/cursor/README.md

@@ -0,0 +1,33 @@
+# Cursor Adapter for OpenCLI
+
+Control the **Cursor IDE** from the terminal via Chrome DevTools Protocol (CDP). Since Cursor is built on Electron (VS Code fork), OpenCLI can drive its internal UI, automate Composer interactions, and manipulate chat sessions.
+
+## Prerequisites
+
+1. Install [Cursor](https://cursor.sh/).
+2. Launch it with the remote debugging port:
+   ```bash
+   /Applications/Cursor.app/Contents/MacOS/Cursor --remote-debugging-port=9226
+   ```
+
+## Setup
+
+```bash
+export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9226"
+```
+
+## Commands
+
+### Diagnostics
+- `opencli cursor status`: Check CDP connection status.
+- `opencli cursor dump`: Dump the full DOM and Accessibility snapshot to `/tmp/cursor-dom.html` and `/tmp/cursor-snapshot.json`.
+
+### Chat Manipulation
+- `opencli cursor new`: Press `Cmd+N` to start a new file/tab.
+- `opencli cursor send "message"`: Inject text into the active Composer/Chat input and submit.
+- `opencli cursor read`: Extract the full conversation history from the active chat panel.
+
+### AI Features
+- `opencli cursor composer "prompt"`: Open the Composer panel (`Cmd+I`) and send a prompt for inline AI editing.
+- `opencli cursor model`: Get the currently active AI model (e.g., `claude-4.5-sonnet`).
+- `opencli cursor extract-code`: Extract all code blocks from the current conversation.