@jackwener/opencli 0.9.4 → 0.9.6

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

@@ -0,0 +1,33 @@
+# Cursor 适配器
+
+通过 Chrome DevTools Protocol (CDP) 在终端中控制 **Cursor IDE**。由于 Cursor 基于 Electron（VS Code 分支），OpenCLI 可以驱动其内部 UI，自动化 Composer 交互，操控聊天会话。
+
+## 前置条件
+
+1. 安装 [Cursor](https://cursor.sh/)。
+2. 通过远程调试端口启动：
+   ```bash
+   /Applications/Cursor.app/Contents/MacOS/Cursor --remote-debugging-port=9226
+   ```
+
+## 配置
+
+```bash
+export OPENCLI_CDP_ENDPOINT="http://127.0.0.1:9226"
+```
+
+## 命令
+
+### 诊断
+- `opencli cursor status`：检查 CDP 连接状态。
+- `opencli cursor dump`：导出完整 DOM 和 Accessibility 快照到 `/tmp/cursor-dom.html` 和 `/tmp/cursor-snapshot.json`。
+
+### 对话操作
+- `opencli cursor new`：按 `Cmd+N` 创建新文件/标签。
+- `opencli cursor send "消息"`：将文本注入活跃的 Composer/Chat 输入框并提交。
+- `opencli cursor read`：提取当前聊天面板的完整对话历史。
+
+### AI 功能
+- `opencli cursor composer "提示词"`：打开 Composer 面板（`Cmd+I`）并发送提示词进行内联 AI 编辑。
+- `opencli cursor model`：获取当前活跃的 AI 模型（如 `claude-4.5-sonnet`）。
+- `opencli cursor extract-code`：从当前对话中提取所有代码块。

package/src/clis/cursor/ask.ts

@@ -0,0 +1,81 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: IPage, kwargs: any) => {
+    const text = kwargs.text as string;
+    const timeout = parseInt(kwargs.timeout as string, 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/src/clis/cursor/composer.ts

@@ -13,37 +13,18 @@ export const composerCommand = cli({
   func: async (page: IPage, kwargs: any) => {
     const textToInsert = kwargs.text as string;
 
-    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);
@@ -55,15 +36,13 @@ export const composerCommand = cli({
       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/src/clis/cursor/export.ts

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

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: IPage) => {
+    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/src/clis/cursor/new.ts

@@ -8,23 +8,12 @@ export const newCommand = cli({
   domain: 'localhost',
   strategy: Strategy.UI,
   browser: true,
+  args: [],
   columns: ['Status'],
   func: async (page: IPage) => {
-    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/src/clis/cursor/screenshot.ts

@@ -0,0 +1,38 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+function makeScreenshotCommand(site: string) {
+  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: IPage, kwargs: any) => {
+      const outputPath = (kwargs.output as string) || `/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');