@jackwener/opencli 0.9.6 → 0.9.8

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/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;

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

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

package/dist/clis/discord-app/channels.js

@@ -0,0 +1,45 @@
+import { cli, Strategy } from '../../registry.js';
+export const channelsCommand = cli({
+    site: 'discord-app',
+    name: 'channels',
+    description: 'List channels in the current Discord server',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Channel', 'Type'],
+    func: async (page) => {
+        const channels = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Discord channel list items
+        const items = document.querySelectorAll('[data-list-item-id*="channels___"], [class*="containerDefault_"]');
+        
+        items.forEach((item, i) => {
+          const nameEl = item.querySelector('[class*="name_"], [class*="channelName"]');
+          const name = nameEl ? nameEl.textContent.trim() : (item.textContent || '').trim().substring(0, 50);
+          
+          if (!name || name.length < 1) return;
+          
+          // Detect channel type from icon or aria-label
+          const iconEl = item.querySelector('[class*="icon"]');
+          let type = 'Text';
+          if (iconEl) {
+            const cls = iconEl.className || '';
+            if (cls.includes('voice') || cls.includes('speaker')) type = 'Voice';
+            else if (cls.includes('forum')) type = 'Forum';
+            else if (cls.includes('announcement')) type = 'Announcement';
+          }
+          
+          results.push({ Index: i + 1, Channel: name, Type: type });
+        });
+        
+        return results;
+      })()
+    `);
+        if (channels.length === 0) {
+            return [{ Index: 0, Channel: 'No channels found', Type: '—' }];
+        }
+        return channels;
+    },
+});

package/dist/clis/discord-app/members.d.ts

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