@jackwener/opencli 0.9.5 → 0.9.8

package/dist/clis/chatwise/send.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'chatwise',
+    name: 'send',
+    description: 'Send a message to the active ChatWise conversation',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+    columns: ['Status', 'InjectedText'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        await page.evaluate(`
+      (function(text) {
+        // ChatWise input can be textarea or contenteditable
+        let composer = document.querySelector('textarea');
+        if (!composer) {
+          const editables = Array.from(document.querySelectorAll('[contenteditable="true"]'));
+          composer = editables.length > 0 ? editables[editables.length - 1] : null;
+        }
+
+        if (!composer) throw new Error('Could not find ChatWise input element');
+
+        composer.focus();
+        
+        if (composer.tagName === 'TEXTAREA') {
+          // For textarea, set value and dispatch input event
+          const nativeInputValueSetter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
+          nativeInputValueSetter.call(composer, text);
+          composer.dispatchEvent(new Event('input', { bubbles: true }));
+        } else {
+          document.execCommand('insertText', false, text);
+        }
+      })(${JSON.stringify(text)})
+    `);
+        await page.wait(0.5);
+        await page.pressKey('Enter');
+        return [
+            {
+                Status: 'Success',
+                InjectedText: text,
+            },
+        ];
+    },
+});

package/dist/clis/chatwise/status.d.ts

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

package/dist/clis/chatwise/status.js

@@ -0,0 +1,22 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'chatwise',
+    name: 'status',
+    description: 'Check active CDP connection to ChatWise Desktop',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status', 'Url', 'Title'],
+    func: async (page) => {
+        const url = await page.evaluate('window.location.href');
+        const title = await page.evaluate('document.title');
+        return [
+            {
+                Status: 'Connected',
+                Url: url,
+                Title: title,
+            },
+        ];
+    },
+});

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

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

package/dist/clis/codex/ask.js

@@ -0,0 +1,67 @@
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        const text = kwargs.text;
+        const timeout = parseInt(kwargs.timeout, 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/dist/clis/codex/export.d.ts

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

package/dist/clis/codex/export.js

@@ -0,0 +1,37 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        const outputPath = kwargs.output || '/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/dist/clis/codex/history.d.ts

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

package/dist/clis/codex/history.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '../../registry.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) => {
+        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/dist/clis/codex/read.js

@@ -6,30 +6,28 @@ export const readCommand = cli({
     domain: 'localhost',
     strategy: Strategy.UI,
     browser: true,
-    columns: ['Thread_Content'],
+    args: [],
+    columns: ['Content'],
     func: async (page) => {
         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/dist/clis/codex/screenshot.d.ts

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

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/dist/clis/discord-app/channels.d.ts

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