@jackwener/opencli 0.9.5 → 0.9.8

package/dist/clis/antigravity/model.js

@@ -9,7 +9,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();
         await page.evaluate(`
@@ -39,6 +39,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/dist/clis/antigravity/send.js

@@ -9,7 +9,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;
         // We use evaluate to focus and insert text because Lexical editors maintain
@@ -30,6 +30,6 @@ export const sendCommand = cli({
         await page.wait(0.5);
         // Press Enter to submit the message
         await page.pressKey('Enter');
-        return [{ status: 'Sent successfully', message: text }];
+        return [{ Status: 'Sent successfully', Message: text }];
     },
 });

package/dist/clis/bilibili/download.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Bilibili download — download videos using yt-dlp.
+ *
+ * Usage:
+ *   opencli bilibili download --bvid BV1xxx --output ./bilibili
+ *
+ * Requirements:
+ *   - yt-dlp must be installed: pip install yt-dlp
+ */
+export {};

package/dist/clis/bilibili/download.js

@@ -0,0 +1,135 @@
+/**
+ * Bilibili download — download videos using yt-dlp.
+ *
+ * Usage:
+ *   opencli bilibili download --bvid BV1xxx --output ./bilibili
+ *
+ * Requirements:
+ *   - yt-dlp must be installed: pip install yt-dlp
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { ytdlpDownload, checkYtdlp, sanitizeFilename, getTempDir, exportCookiesToNetscape, } from '../../download/index.js';
+import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
+cli({
+    site: 'bilibili',
+    name: 'download',
+    description: '下载B站视频（需要 yt-dlp）',
+    domain: 'www.bilibili.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'bvid', required: true, help: 'Video BV ID (e.g., BV1xxx)' },
+        { name: 'output', default: './bilibili-downloads', help: 'Output directory' },
+        { name: 'quality', default: 'best', help: 'Video quality (best, 1080p, 720p, 480p)' },
+    ],
+    columns: ['bvid', 'title', 'status', 'size'],
+    func: async (page, kwargs) => {
+        const bvid = kwargs.bvid;
+        const output = kwargs.output;
+        const quality = kwargs.quality;
+        // Check yt-dlp availability
+        if (!checkYtdlp()) {
+            return [{
+                    bvid,
+                    title: '-',
+                    status: 'failed',
+                    size: 'yt-dlp not installed. Run: pip install yt-dlp',
+                }];
+        }
+        // Navigate to video page to get title and cookies
+        await page.goto(`https://www.bilibili.com/video/${bvid}`);
+        await page.wait(3);
+        // Extract video info
+        const data = await page.evaluate(`
+      (() => {
+        const title = document.querySelector('h1.video-title, .video-title')?.textContent?.trim() || 'video';
+        const author = document.querySelector('.up-name, .username')?.textContent?.trim() || 'unknown';
+        return { title, author };
+      })()
+    `);
+        const title = sanitizeFilename(data?.title || 'video');
+        // Extract cookies for authenticated downloads
+        const cookieString = await page.evaluate(`(() => document.cookie)()`);
+        // Create output directory
+        fs.mkdirSync(output, { recursive: true });
+        // Export cookies to Netscape format for yt-dlp
+        let cookiesFile;
+        if (typeof cookieString === 'string' && cookieString) {
+            const tempDir = getTempDir();
+            fs.mkdirSync(tempDir, { recursive: true });
+            cookiesFile = path.join(tempDir, `bilibili_cookies_${Date.now()}.txt`);
+            const cookies = cookieString.split(';').map((c) => {
+                const [name, ...rest] = c.trim().split('=');
+                return {
+                    name: name || '',
+                    value: rest.join('=') || '',
+                    domain: '.bilibili.com',
+                    path: '/',
+                    secure: true,
+                    httpOnly: false,
+                };
+            }).filter((c) => c.name);
+            exportCookiesToNetscape(cookies, cookiesFile);
+        }
+        // Build yt-dlp format string based on quality
+        let format = 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best';
+        if (quality === '1080p') {
+            format = 'bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080]';
+        }
+        else if (quality === '720p') {
+            format = 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720]';
+        }
+        else if (quality === '480p') {
+            format = 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480]';
+        }
+        const destPath = path.join(output, `${bvid}_${title}.mp4`);
+        const tracker = new DownloadProgressTracker(1, true);
+        const progressBar = tracker.onFileStart(`${bvid}.mp4`, 0);
+        try {
+            const result = await ytdlpDownload(`https://www.bilibili.com/video/${bvid}`, destPath, {
+                cookiesFile,
+                format,
+                extraArgs: [
+                    '--merge-output-format', 'mp4',
+                    '--embed-thumbnail',
+                ],
+                onProgress: (percent) => {
+                    if (progressBar)
+                        progressBar.update(percent, 100);
+                },
+            });
+            if (progressBar) {
+                progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+            }
+            tracker.onFileComplete(result.success);
+            tracker.finish();
+            // Cleanup cookies file
+            if (cookiesFile && fs.existsSync(cookiesFile)) {
+                fs.unlinkSync(cookiesFile);
+            }
+            return [{
+                    bvid,
+                    title: data?.title || 'video',
+                    status: result.success ? 'success' : 'failed',
+                    size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+                }];
+        }
+        catch (err) {
+            if (progressBar)
+                progressBar.fail(err.message);
+            tracker.onFileComplete(false);
+            tracker.finish();
+            // Cleanup cookies file
+            if (cookiesFile && fs.existsSync(cookiesFile)) {
+                fs.unlinkSync(cookiesFile);
+            }
+            return [{
+                    bvid,
+                    title: data?.title || 'video',
+                    status: 'failed',
+                    size: err.message,
+                }];
+        }
+    },
+});

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

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

package/dist/clis/chatgpt/ask.js

@@ -0,0 +1,68 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        const text = kwargs.text;
+        const timeout = parseInt(kwargs.timeout, 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/dist/clis/chatgpt/send.js

@@ -12,6 +12,13 @@ export const sendCommand = cli({
     func: async (page, kwargs) => {
         const text = kwargs.text;
         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'");
@@ -22,6 +29,10 @@ export const sendCommand = cli({
                 "-e 'keystroke return' " +
                 "-e 'end tell'";
             execSync(cmd);
+            // Restore original clipboard content
+            if (clipBackup) {
+                spawnSync('pbcopy', { input: clipBackup });
+            }
             return [{ Status: 'Success' }];
         }
         catch (err) {

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

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

package/dist/clis/chatwise/ask.js

@@ -0,0 +1,76 @@
+import { cli, Strategy } from '../../registry.js';
+export const askCommand = cli({
+    site: 'chatwise',
+    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 (default: 30)', default: '30' },
+    ],
+    columns: ['Role', 'Text'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        const timeout = parseInt(kwargs.timeout, 10) || 30;
+        // Snapshot content length
+        const beforeLen = await page.evaluate(`
+      (function() {
+        const msgs = document.querySelectorAll('[data-message-id], [class*="message"], [class*="bubble"]');
+        return msgs.length;
+      })()
+    `);
+        // Send message
+        await page.evaluate(`
+      (function(text) {
+        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 input');
+        composer.focus();
+        if (composer.tagName === 'TEXTAREA') {
+          const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set;
+          setter.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');
+        // Poll for response
+        const pollInterval = 2;
+        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 msgs = document.querySelectorAll('[data-message-id], [class*="message"], [class*="bubble"]');
+          if (msgs.length <= prevLen) return null;
+          const last = msgs[msgs.length - 1];
+          const text = last.innerText || last.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.` },
+            ];
+        }
+        return [
+            { Role: 'User', Text: text },
+            { Role: 'Assistant', Text: response },
+        ];
+    },
+});

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

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

package/dist/clis/chatwise/export.js

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

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

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

package/dist/clis/chatwise/history.js

@@ -0,0 +1,43 @@
+import { cli, Strategy } from '../../registry.js';
+export const historyCommand = cli({
+    site: 'chatwise',
+    name: 'history',
+    description: 'List conversation history in ChatWise sidebar',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Title'],
+    func: async (page) => {
+        const items = await page.evaluate(`
+      (function() {
+        const results = [];
+        const selectors = [
+          '[class*="sidebar"] [class*="item"]',
+          '[class*="conversation-list"] a',
+          '[class*="chat-list"] > *',
+          'nav a',
+          'aside a',
+          '[role="listbox"] [role="option"]',
+        ];
+        
+        for (const sel of selectors) {
+          const nodes = document.querySelectorAll(sel);
+          if (nodes.length > 0) {
+            nodes.forEach((n, i) => {
+              const text = (n.textContent || '').trim().substring(0, 100);
+              if (text) results.push({ Index: i + 1, Title: text });
+            });
+            break;
+          }
+        }
+        
+        return results;
+      })()
+    `);
+        if (items.length === 0) {
+            return [{ Index: 0, Title: 'No history found. Ensure the sidebar is visible.' }];
+        }
+        return items;
+    },
+});

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

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

package/dist/clis/chatwise/model.js

@@ -0,0 +1,81 @@
+import { cli, Strategy } from '../../registry.js';
+export const modelCommand = cli({
+    site: 'chatwise',
+    name: 'model',
+    description: 'Get or switch the active AI model in ChatWise',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'model_name', required: false, positional: true, help: 'Model to switch to (e.g. gpt-4, claude-3)' },
+    ],
+    columns: ['Status', 'Model'],
+    func: async (page, kwargs) => {
+        const desiredModel = kwargs.model_name;
+        if (!desiredModel) {
+            // Read current model
+            const currentModel = await page.evaluate(`
+        (function() {
+          // ChatWise is a multi-LLM client, it typically shows the model name in a dropdown or header
+          const selectors = [
+            '[class*="model"] span',
+            '[class*="Model"] span',
+            '[data-testid*="model"]',
+            'button[class*="model"]',
+            '[aria-label*="Model"]',
+            '[aria-label*="model"]',
+          ];
+          
+          for (const sel of selectors) {
+            const el = document.querySelector(sel);
+            if (el) {
+              const text = (el.textContent || el.getAttribute('title') || '').trim();
+              if (text) return text;
+            }
+          }
+          
+          return 'Unknown or Not Found';
+        })()
+      `);
+            return [{ Status: 'Active', Model: currentModel }];
+        }
+        else {
+            // Try to switch model
+            await page.evaluate(`
+        (function(target) {
+          const selectors = [
+            '[class*="model"]',
+            '[class*="Model"]',
+            'button[class*="model"]',
+          ];
+          
+          for (const sel of selectors) {
+            const el = document.querySelector(sel);
+            if (el) { el.click(); return; }
+          }
+          throw new Error('Could not find model selector');
+        })(${JSON.stringify(desiredModel)})
+      `);
+            await page.wait(0.5);
+            // Find and click the target model in the dropdown
+            const found = await page.evaluate(`
+        (function(target) {
+          const options = document.querySelectorAll('[role="option"], [role="menuitem"], [class*="dropdown-item"], li');
+          for (const opt of options) {
+            if ((opt.textContent || '').toLowerCase().includes(target.toLowerCase())) {
+              opt.click();
+              return true;
+            }
+          }
+          return false;
+        })(${JSON.stringify(desiredModel)})
+      `);
+            return [
+                {
+                    Status: found ? 'Switched' : 'Dropdown opened but model not found',
+                    Model: desiredModel,
+                },
+            ];
+        }
+    },
+});

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

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

package/dist/clis/chatwise/new.js

@@ -0,0 +1,18 @@
+import { cli, Strategy } from '../../registry.js';
+export const newCommand = cli({
+    site: 'chatwise',
+    name: 'new',
+    description: 'Start a new conversation in ChatWise',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        // ChatWise uses standard Electron shortcuts
+        const isMac = process.platform === 'darwin';
+        await page.pressKey(isMac ? 'Meta+N' : 'Control+N');
+        await page.wait(1);
+        return [{ Status: 'Success' }];
+    },
+});

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

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

package/dist/clis/chatwise/read.js

@@ -0,0 +1,39 @@
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'chatwise',
+    name: 'read',
+    description: 'Read the current ChatWise conversation history',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Content'],
+    func: async (page) => {
+        const content = await page.evaluate(`
+      (function() {
+        // Try common chat message selectors
+        const selectors = [
+          '[data-message-id]',
+          '[class*="message"]',
+          '[class*="chat-item"]',
+          '[class*="bubble"]',
+          '[role="log"] > *',
+        ];
+        
+        for (const sel of selectors) {
+          const nodes = document.querySelectorAll(sel);
+          if (nodes.length > 0) {
+            return Array.from(nodes).map(n => (n.innerText || n.textContent).trim()).filter(Boolean).join('\\n\\n---\\n\\n');
+          }
+        }
+        
+        // Fallback: main content area
+        const main = document.querySelector('main, [role="main"], [class*="chat-container"], [class*="conversation"]');
+        if (main) return main.innerText || main.textContent;
+        
+        return document.body.innerText;
+      })()
+    `);
+        return [{ Content: content }];
+    },
+});

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

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

package/dist/clis/chatwise/screenshot.js

@@ -0,0 +1,27 @@
+import * as fs from 'node:fs';
+import { cli, Strategy } from '../../registry.js';
+export const screenshotCommand = cli({
+    site: 'chatwise',
+    name: 'screenshot',
+    description: 'Capture a snapshot of the current ChatWise window (DOM + Accessibility tree)',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'output', required: false, positional: true, help: 'Output file path (default: /tmp/chatwise-snapshot)' },
+    ],
+    columns: ['Status', 'File'],
+    func: async (page, kwargs) => {
+        const basePath = kwargs.output || '/tmp/chatwise-snapshot';
+        const snap = await page.snapshot({ compact: true });
+        const html = await page.evaluate('document.documentElement.outerHTML');
+        const htmlPath = basePath + '-dom.html';
+        const snapPath = basePath + '-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/chatwise/send.d.ts

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