@jackwener/opencli 0.9.5 → 0.9.6

package/src/clis/chatgpt/send.ts

@@ -14,6 +14,13 @@ export const sendCommand = cli({
   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'");
@@ -28,6 +35,11 @@ export const sendCommand = cli({
                      
       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/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/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');