@jackwener/opencli 0.9.5 → 0.9.8

package/dist/clis/notion/sidebar.js

@@ -0,0 +1,41 @@
+import { cli, Strategy } from '../../registry.js';
+export const sidebarCommand = cli({
+    site: 'notion',
+    name: 'sidebar',
+    description: 'List pages and databases from the Notion sidebar',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [],
+    columns: ['Index', 'Title'],
+    func: async (page) => {
+        const items = await page.evaluate(`
+      (function() {
+        const results = [];
+        // Notion sidebar items
+        const selectors = [
+          '[class*="sidebar"] [role="treeitem"]',
+          '[class*="sidebar"] a',
+          '.notion-sidebar [role="button"]',
+          'nav [role="treeitem"]',
+        ];
+        
+        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 && text.length > 1) results.push({ Index: i + 1, Title: text });
+            });
+            break;
+          }
+        }
+        return results;
+      })()
+    `);
+        if (items.length === 0) {
+            return [{ Index: 0, Title: 'No sidebar items found. Toggle the sidebar first.' }];
+        }
+        return items;
+    },
+});

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

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

package/dist/clis/notion/status.js

@@ -0,0 +1,16 @@
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'notion',
+    name: 'status',
+    description: 'Check active CDP connection to Notion 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/notion/write.d.ts

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

package/dist/clis/notion/write.js

@@ -0,0 +1,40 @@
+import { cli, Strategy } from '../../registry.js';
+export const writeCommand = cli({
+    site: 'notion',
+    name: 'write',
+    description: 'Append text content to the currently open Notion page',
+    domain: 'localhost',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [{ name: 'text', required: true, positional: true, help: 'Text to append to the page' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        // Focus the page body and move to the end
+        await page.evaluate(`
+      (function(text) {
+        // Find the editable area in Notion
+        const editables = document.querySelectorAll('.notion-page-content [contenteditable="true"], [class*="page-content"] [contenteditable="true"]');
+        let target = editables.length > 0 ? editables[editables.length - 1] : null;
+        
+        if (!target) {
+          // Fallback: just find any contenteditable
+          const all = document.querySelectorAll('[contenteditable="true"]');
+          target = all.length > 0 ? all[all.length - 1] : null;
+        }
+        
+        if (!target) throw new Error('Could not find editable area in Notion page');
+        
+        target.focus();
+        // Move to end
+        const sel = window.getSelection();
+        sel.selectAllChildren(target);
+        sel.collapseToEnd();
+        
+        document.execCommand('insertText', false, text);
+      })(${JSON.stringify(text)})
+    `);
+        await page.wait(0.5);
+        return [{ Status: 'Text appended successfully' }];
+    },
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Twitter/X download — download images and videos from tweets.
+ *
+ * Usage:
+ *   opencli twitter download --username elonmusk --limit 10 --output ./twitter
+ *   opencli twitter download --tweet-url https://x.com/xxx/status/123 --output ./twitter
+ */
+export {};

package/dist/clis/twitter/download.js

@@ -0,0 +1,204 @@
+/**
+ * Twitter/X download — download images and videos from tweets.
+ *
+ * Usage:
+ *   opencli twitter download --username elonmusk --limit 10 --output ./twitter
+ *   opencli twitter download --tweet-url https://x.com/xxx/status/123 --output ./twitter
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { httpDownload, ytdlpDownload, checkYtdlp, getTempDir, exportCookiesToNetscape, } from '../../download/index.js';
+import { DownloadProgressTracker, formatBytes } from '../../download/progress.js';
+cli({
+    site: 'twitter',
+    name: 'download',
+    description: '下载 Twitter/X 媒体（图片和视频）',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'username', help: 'Twitter username (downloads from media tab)' },
+        { name: 'tweet-url', help: 'Single tweet URL to download' },
+        { name: 'limit', type: 'int', default: 10, help: 'Number of tweets to scan' },
+        { name: 'output', default: './twitter-downloads', help: 'Output directory' },
+    ],
+    columns: ['index', 'type', 'status', 'size'],
+    func: async (page, kwargs) => {
+        const username = kwargs.username;
+        const tweetUrl = kwargs['tweet-url'];
+        const limit = kwargs.limit;
+        const output = kwargs.output;
+        if (!username && !tweetUrl) {
+            return [{
+                    index: 0,
+                    type: '-',
+                    status: 'failed',
+                    size: 'Must provide --username or --tweet-url',
+                }];
+        }
+        // Navigate to the appropriate page
+        if (tweetUrl) {
+            await page.goto(tweetUrl);
+        }
+        else {
+            await page.goto(`https://x.com/${username}/media`);
+        }
+        await page.wait(3);
+        // Scroll to load more content
+        if (!tweetUrl) {
+            await page.autoScroll({ times: Math.ceil(limit / 5) });
+        }
+        // Extract media URLs
+        const data = await page.evaluate(`
+      (() => {
+        const media = [];
+
+        // Find images (high quality)
+        document.querySelectorAll('img[src*="pbs.twimg.com/media"]').forEach(img => {
+          let src = img.src || '';
+          // Get large version
+          src = src.replace(/&name=\\w+$/, '&name=large');
+          src = src.replace(/\\?format=/, '?format=');
+          if (!src.includes('&name=')) {
+            src = src + '&name=large';
+          }
+          media.push({ type: 'image', url: src });
+        });
+
+        // Find videos
+        document.querySelectorAll('video').forEach(video => {
+          const src = video.src || '';
+          if (src) {
+            media.push({ type: 'video', url: src, poster: video.poster || '' });
+          }
+        });
+
+        // Find video tweets (for yt-dlp)
+        document.querySelectorAll('[data-testid="videoPlayer"]').forEach(player => {
+          const tweetLink = player.closest('article')?.querySelector('a[href*="/status/"]');
+          const href = tweetLink?.getAttribute('href') || '';
+          if (href) {
+            const tweetUrl = 'https://x.com' + href;
+            media.push({ type: 'video-tweet', url: tweetUrl });
+          }
+        });
+
+        return media;
+      })()
+    `);
+        if (!data || data.length === 0) {
+            return [{
+                    index: 0,
+                    type: '-',
+                    status: 'failed',
+                    size: 'No media found',
+                }];
+        }
+        // Extract cookies
+        const cookieString = await page.evaluate(`(() => document.cookie)()`);
+        // Create output directory
+        const outputDir = tweetUrl
+            ? path.join(output, 'tweets')
+            : path.join(output, username || 'media');
+        fs.mkdirSync(outputDir, { recursive: true });
+        // Export cookies for yt-dlp
+        let cookiesFile;
+        if (typeof cookieString === 'string' && cookieString) {
+            const tempDir = getTempDir();
+            fs.mkdirSync(tempDir, { recursive: true });
+            cookiesFile = path.join(tempDir, `twitter_cookies_${Date.now()}.txt`);
+            const cookies = cookieString.split(';').map((c) => {
+                const [name, ...rest] = c.trim().split('=');
+                return {
+                    name: name || '',
+                    value: rest.join('=') || '',
+                    domain: '.x.com',
+                    path: '/',
+                    secure: true,
+                    httpOnly: false,
+                };
+            }).filter((c) => c.name);
+            exportCookiesToNetscape(cookies, cookiesFile);
+        }
+        // Deduplicate media
+        const seen = new Set();
+        const uniqueMedia = data.filter((m) => {
+            if (seen.has(m.url))
+                return false;
+            seen.add(m.url);
+            return true;
+        }).slice(0, limit);
+        const tracker = new DownloadProgressTracker(uniqueMedia.length, true);
+        const results = [];
+        for (let i = 0; i < uniqueMedia.length; i++) {
+            const media = uniqueMedia[i];
+            const ext = media.type === 'image' ? 'jpg' : 'mp4';
+            const filename = `${username || 'tweet'}_${i + 1}.${ext}`;
+            const destPath = path.join(outputDir, filename);
+            const progressBar = tracker.onFileStart(filename, i);
+            try {
+                let result;
+                if (media.type === 'video-tweet' && checkYtdlp()) {
+                    // Use yt-dlp for video tweets
+                    result = await ytdlpDownload(media.url, destPath, {
+                        cookiesFile,
+                        extraArgs: ['--merge-output-format', 'mp4'],
+                        onProgress: (percent) => {
+                            if (progressBar)
+                                progressBar.update(percent, 100);
+                        },
+                    });
+                }
+                else if (media.type === 'image') {
+                    // Direct HTTP download for images
+                    result = await httpDownload(media.url, destPath, {
+                        cookies: typeof cookieString === 'string' ? cookieString : '',
+                        timeout: 30000,
+                        onProgress: (received, total) => {
+                            if (progressBar)
+                                progressBar.update(received, total);
+                        },
+                    });
+                }
+                else {
+                    // Direct HTTP download for direct video URLs
+                    result = await httpDownload(media.url, destPath, {
+                        cookies: typeof cookieString === 'string' ? cookieString : '',
+                        timeout: 60000,
+                        onProgress: (received, total) => {
+                            if (progressBar)
+                                progressBar.update(received, total);
+                        },
+                    });
+                }
+                if (progressBar) {
+                    progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+                }
+                tracker.onFileComplete(result.success);
+                results.push({
+                    index: i + 1,
+                    type: media.type === 'video-tweet' ? 'video' : media.type,
+                    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);
+                results.push({
+                    index: i + 1,
+                    type: media.type,
+                    status: 'failed',
+                    size: err.message,
+                });
+            }
+        }
+        tracker.finish();
+        // Cleanup cookies file
+        if (cookiesFile && fs.existsSync(cookiesFile)) {
+            fs.unlinkSync(cookiesFile);
+        }
+        return results;
+    },
+});

package/dist/clis/wechat/chats.d.ts

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

package/dist/clis/wechat/chats.js

@@ -0,0 +1,28 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const chatsCommand = cli({
+    site: 'wechat',
+    name: 'chats',
+    description: 'Open the WeChat chats panel (conversation list)',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        try {
+            // Activate WeChat
+            execSync("osascript -e 'tell application \"WeChat\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Cmd+1 switches to Chats tab in WeChat Mac
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"1\" using command down' " +
+                "-e 'end tell'");
+            return [{ Status: 'Chats panel opened (Cmd+1)' }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/wechat/contacts.d.ts

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

package/dist/clis/wechat/contacts.js

@@ -0,0 +1,28 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const contactsCommand = cli({
+    site: 'wechat',
+    name: 'contacts',
+    description: 'Open the WeChat contacts panel',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status'],
+    func: async (page) => {
+        try {
+            // Activate WeChat
+            execSync("osascript -e 'tell application \"WeChat\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Cmd+2 switches to Contacts tab in WeChat Mac
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"2\" using command down' " +
+                "-e 'end tell'");
+            return [{ Status: 'Contacts panel opened (Cmd+2)' }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

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

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

package/dist/clis/wechat/read.js

@@ -0,0 +1,58 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const readCommand = cli({
+    site: 'wechat',
+    name: 'read',
+    description: 'Read the current chat content by selecting all and copying',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Content'],
+    func: async (page) => {
+        try {
+            // Backup clipboard
+            let clipBackup = '';
+            try {
+                clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+            }
+            catch { /* empty */ }
+            // Activate WeChat
+            execSync("osascript -e 'tell application \"WeChat\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Click on the chat area first, then select all and copy
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'tell application process \"WeChat\"' " +
+                // Click in the message area (center-right of the window)
+                "-e 'set frontWin to front window' " +
+                "-e 'set winPos to position of frontWin' " +
+                "-e 'set winSize to size of frontWin' " +
+                "-e 'end tell' " +
+                "-e 'end tell'");
+            execSync("osascript -e 'delay 0.2'");
+            // Select all text in chat area and copy
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"a\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'keystroke \"c\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'end tell'");
+            const content = execSync('pbpaste', { encoding: 'utf-8' }).trim();
+            // Restore clipboard
+            if (clipBackup) {
+                spawnSync('pbcopy', { input: clipBackup });
+            }
+            // Press Escape to deselect
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'key code 53' " + // Escape
+                "-e 'end tell'");
+            return [{ Content: content || '(no content captured)' }];
+        }
+        catch (err) {
+            return [{ Content: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/wechat/search.d.ts

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

package/dist/clis/wechat/search.js

@@ -0,0 +1,31 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const searchCommand = cli({
+    site: 'wechat',
+    name: 'search',
+    description: 'Open WeChat search and type a query (find contacts or messages)',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'query', required: true, positional: true, help: 'Search query (contact name or keyword)' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const query = kwargs.query;
+        try {
+            // Activate WeChat
+            execSync("osascript -e 'tell application \"WeChat\" to activate'");
+            execSync("osascript -e 'delay 0.3'");
+            // Cmd+F to open search (WeChat Mac uses Cmd+F for search)
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"f\" using command down' " +
+                "-e 'delay 0.5' " +
+                `-e 'keystroke ${JSON.stringify(query)}' ` +
+                "-e 'end tell'");
+            return [{ Status: `Searching for: ${query}` }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

package/dist/clis/wechat/send.d.ts

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

package/dist/clis/wechat/send.js

@@ -0,0 +1,42 @@
+import { execSync, spawnSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const sendCommand = cli({
+    site: 'wechat',
+    name: 'send',
+    description: 'Send a message in the active WeChat conversation via clipboard paste',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [{ name: 'text', required: true, positional: true, help: 'Message to send' }],
+    columns: ['Status'],
+    func: async (page, kwargs) => {
+        const text = kwargs.text;
+        try {
+            // Backup clipboard
+            let clipBackup = '';
+            try {
+                clipBackup = execSync('pbpaste', { encoding: 'utf-8' });
+            }
+            catch { /* clipboard may be empty */ }
+            // Copy text to clipboard
+            spawnSync('pbcopy', { input: text });
+            // Activate WeChat and paste
+            execSync("osascript -e 'tell application \"WeChat\" to activate'");
+            execSync("osascript -e 'delay 0.5'");
+            execSync("osascript " +
+                "-e 'tell application \"System Events\"' " +
+                "-e 'keystroke \"v\" using command down' " +
+                "-e 'delay 0.2' " +
+                "-e 'keystroke return' " +
+                "-e 'end tell'");
+            // Restore clipboard
+            if (clipBackup) {
+                spawnSync('pbcopy', { input: clipBackup });
+            }
+            return [{ Status: 'Success' }];
+        }
+        catch (err) {
+            return [{ Status: 'Error: ' + err.message }];
+        }
+    },
+});

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

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

package/dist/clis/wechat/status.js

@@ -0,0 +1,29 @@
+import { execSync } from 'node:child_process';
+import { cli, Strategy } from '../../registry.js';
+export const statusCommand = cli({
+    site: 'wechat',
+    name: 'status',
+    description: 'Check if WeChat Desktop is running on macOS',
+    domain: 'localhost',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['Status', 'Detail'],
+    func: async (page) => {
+        try {
+            const running = execSync("osascript -e 'application \"WeChat\" is running'", { encoding: 'utf-8' }).trim();
+            if (running !== 'true') {
+                return [{ Status: 'Stopped', Detail: 'WeChat is not running' }];
+            }
+            // Get window count to check if logged in
+            const windowCount = execSync("osascript -e 'tell application \"System Events\" to count windows of application process \"WeChat\"'", { encoding: 'utf-8' }).trim();
+            return [{
+                    Status: 'Running',
+                    Detail: `${windowCount} window(s) open`,
+                }];
+        }
+        catch (err) {
+            return [{ Status: 'Error', Detail: err.message }];
+        }
+    },
+});

package/dist/clis/xiaohongshu/creator-note-detail.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Xiaohongshu Creator Note Detail — per-note analytics breakdown.
+ *
+ * Uses the creator.xiaohongshu.com internal API (cookie auth).
+ * Returns total reads, engagement, likes, collects, comments, shares
+ * for a specific note, split by channel (organic vs promoted vs video).
+ *
+ * Requires: logged into creator.xiaohongshu.com in Chrome.
+ */
+export {};

package/dist/clis/xiaohongshu/creator-note-detail.js

@@ -0,0 +1,88 @@
+/**
+ * Xiaohongshu Creator Note Detail — per-note analytics breakdown.
+ *
+ * Uses the creator.xiaohongshu.com internal API (cookie auth).
+ * Returns total reads, engagement, likes, collects, comments, shares
+ * for a specific note, split by channel (organic vs promoted vs video).
+ *
+ * Requires: logged into creator.xiaohongshu.com in Chrome.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'xiaohongshu',
+    name: 'creator-note-detail',
+    description: '小红书单篇笔记详细数据 (阅读/互动/点赞/收藏/评论/分享，区分自然流量/推广/视频)',
+    domain: 'creator.xiaohongshu.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'note_id', type: 'string', required: true, help: 'Note ID (from note URL or creator-notes command)' },
+    ],
+    columns: ['channel', 'reads', 'engagement', 'likes', 'collects', 'comments', 'shares'],
+    func: async (page, kwargs) => {
+        const noteId = kwargs.note_id;
+        const encodedNoteId = encodeURIComponent(noteId);
+        // Navigate for cookie context
+        await page.goto('https://creator.xiaohongshu.com/new/home');
+        await page.wait(2);
+        const data = await page.evaluate(`
+      async () => {
+        try {
+          const resp = await fetch(
+            '/api/galaxy/creator/data/note_detail?note_id=${encodedNoteId}',
+            { credentials: 'include' }
+          );
+          if (!resp.ok) return { error: 'HTTP ' + resp.status };
+          return await resp.json();
+        } catch (e) {
+          return { error: e.message };
+        }
+      }
+    `);
+        if (data?.error) {
+            throw new Error(data.error + '. Check note_id and login status.');
+        }
+        if (!data?.data) {
+            throw new Error('Unexpected response structure');
+        }
+        const d = data.data;
+        return [
+            {
+                channel: 'Total',
+                reads: d.total_read ?? 0,
+                engagement: d.total_engage ?? 0,
+                likes: d.total_like ?? 0,
+                collects: d.total_fav ?? 0,
+                comments: d.total_cmt ?? 0,
+                shares: d.total_share ?? 0,
+            },
+            {
+                channel: 'Organic',
+                reads: d.normal_read ?? 0,
+                engagement: d.normal_engage ?? 0,
+                likes: d.normal_like ?? 0,
+                collects: d.normal_fav ?? 0,
+                comments: d.normal_cmt ?? 0,
+                shares: d.normal_share ?? 0,
+            },
+            {
+                channel: 'Promoted',
+                reads: d.total_promo_read ?? 0,
+                engagement: 0,
+                likes: 0,
+                collects: 0,
+                comments: 0,
+                shares: 0,
+            },
+            {
+                channel: 'Video',
+                reads: d.video_read ?? 0,
+                engagement: d.video_engage ?? 0,
+                likes: d.video_like ?? 0,
+                collects: d.video_fav ?? 0,
+                comments: d.video_cmt ?? 0,
+                shares: d.video_share ?? 0,
+            },
+        ];
+    },
+});