@jackwener/opencli 0.4.1 → 0.4.3

package/dist/clis/twitter/notifications.js

@@ -0,0 +1,109 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'notifications',
+    description: 'Get Twitter/X notifications',
+    domain: 'x.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['id', 'action', 'author', 'text', 'url'],
+    func: async (page, kwargs) => {
+        // 1. Navigate to notifications
+        await page.goto('https://x.com/notifications');
+        await page.wait(5);
+        // 2. Inject interceptor
+        await page.installInterceptor('NotificationsTimeline');
+        // 3. Trigger API by scrolling (if we need to load more)
+        await page.autoScroll({ times: 2, delayMs: 2000 });
+        // 4. Retrieve data
+        const requests = await page.getInterceptedRequests();
+        if (!requests || requests.length === 0)
+            return [];
+        let results = [];
+        for (const req of requests) {
+            try {
+                let instructions = [];
+                if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
+                    instructions = req.data.data.viewer.timeline_response.timeline.instructions;
+                }
+                else if (req.data?.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
+                    instructions = req.data.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
+                }
+                else if (req.data?.data?.timeline?.instructions) {
+                    instructions = req.data.data.timeline.instructions;
+                }
+                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
+                // Sometimes it's the first object without a 'type' field but has 'entries'
+                if (!addEntries) {
+                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
+                }
+                if (!addEntries)
+                    continue;
+                for (const entry of addEntries.entries) {
+                    if (!entry.entryId.startsWith('notification-')) {
+                        if (entry.content?.items) {
+                            for (const subItem of entry.content.items) {
+                                processNotificationItem(subItem.item?.itemContent, subItem.entryId);
+                            }
+                        }
+                        continue;
+                    }
+                    processNotificationItem(entry.content?.itemContent, entry.entryId);
+                }
+                function processNotificationItem(itemContent, entryId) {
+                    if (!itemContent)
+                        return;
+                    // Twitter wraps standard notifications 
+                    let item = itemContent?.notification_results?.result || itemContent?.tweet_results?.result || itemContent;
+                    let actionText = 'Notification';
+                    let author = 'unknown';
+                    let text = '';
+                    let urlStr = '';
+                    if (item.__typename === 'TimelineNotification') {
+                        // Greet likes, retweet, mentions
+                        text = item.rich_message?.text || item.message?.text || '';
+                        author = item.template?.from_users?.[0]?.user_results?.result?.core?.screen_name || 'unknown';
+                        urlStr = item.notification_url?.url || '';
+                        actionText = item.notification_icon || 'Activity';
+                        // If there's an attached tweet
+                        const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
+                        if (targetTweet) {
+                            text += ' | ' + (targetTweet.legacy?.full_text || '');
+                            if (!urlStr) {
+                                urlStr = `https://x.com/i/status/${targetTweet.rest_id}`;
+                            }
+                        }
+                    }
+                    else if (item.__typename === 'TweetNotification') {
+                        // Direct mention/reply
+                        const tweet = item.tweet_result?.result;
+                        author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                        text = tweet?.legacy?.full_text || item.message?.text || '';
+                        actionText = 'Mention/Reply';
+                        urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
+                    }
+                    else if (item.__typename === 'Tweet') {
+                        author = item.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                        text = item.legacy?.full_text || '';
+                        actionText = 'Mention';
+                        urlStr = `https://x.com/i/status/${item.rest_id}`;
+                    }
+                    results.push({
+                        id: item.id || item.rest_id || entryId,
+                        action: actionText,
+                        author: author,
+                        text: text,
+                        url: urlStr || `https://x.com/notifications`
+                    });
+                }
+            }
+            catch (e) {
+                // ignore parsing errors for individual payloads
+            }
+        }
+        return results.slice(0, kwargs.limit);
+    }
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/post.js

@@ -0,0 +1,63 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'post',
+    description: 'Post a new tweet/thread',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'text', type: 'string', required: true, help: 'The text content of the tweet' },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        // 1. Navigate directly to the compose tweet modal
+        await page.goto('https://x.com/compose/tweet');
+        await page.wait(3); // Wait for the modal and React app to hydrate
+        // 2. Automate typing and clicking
+        const result = await page.evaluate(`(async () => {
+        try {
+            // Find the active text area
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            if (box) {
+                box.focus();
+                // insertText is the most reliable way to trigger React's onChange events
+                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+            } else {
+                return { ok: false, message: 'Could not find the tweet composer text area.' };
+            }
+            
+            // Wait a brief moment for the button state to update
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Click the post button
+            const btn = document.querySelector('[data-testid="tweetButton"]');
+            if (btn && !btn.disabled) {
+                btn.click();
+                return { ok: true, message: 'Tweet posted successfully.' };
+            } else {
+                // Sometimes it's rendered inline depending on the viewport
+                const inlineBtn = document.querySelector('[data-testid="tweetButtonInline"]');
+                if (inlineBtn && !inlineBtn.disabled) {
+                    inlineBtn.click();
+                    return { ok: true, message: 'Tweet posted successfully.' };
+                }
+                return { ok: false, message: 'Tweet button is disabled or not found.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        // 3. Wait a few seconds for the network request to finish sending
+        if (result.ok) {
+            await page.wait(3);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message,
+                text: kwargs.text
+            }];
+    }
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/reply.js

@@ -0,0 +1,57 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'reply',
+    description: 'Reply to a specific tweet',
+    domain: 'x.com',
+    strategy: Strategy.UI, // Uses the UI directly to input and click post
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to reply to' },
+        { name: 'text', type: 'string', required: true, help: 'The text content of your reply' },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        // 1. Navigate to the tweet page
+        await page.goto(kwargs.url);
+        await page.wait(5); // Wait for the react application to hydrate
+        // 2. Automate typing the reply and clicking reply
+        const result = await page.evaluate(`(async () => {
+        try {
+            // Find the reply text area on the tweet page. 
+            // The placeholder is usually "Post your reply"
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            if (box) {
+                box.focus();
+                document.execCommand('insertText', false, ${JSON.stringify(kwargs.text)});
+            } else {
+                return { ok: false, message: 'Could not find the reply text area. Are you logged in?' };
+            }
+            
+            // Wait for React state to register the input and enable the button
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Find the Reply button. It usually shares the same test id tweetButtonInline in this context
+            const btn = document.querySelector('[data-testid="tweetButtonInline"]');
+            if (btn && !btn.disabled) {
+                btn.click();
+                return { ok: true, message: 'Reply posted successfully.' };
+            } else {
+                return { ok: false, message: 'Reply button is disabled or not found.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            await page.wait(3); // Wait for network submission to complete
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message,
+                text: kwargs.text
+            }];
+    }
+});

package/dist/clis/v2ex/daily.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/v2ex/daily.js

@@ -0,0 +1,98 @@
+/**
+ * V2EX Daily Check-in adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'v2ex',
+    name: 'daily',
+    description: 'V2EX 每日签到并领取铜币',
+    domain: 'www.v2ex.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    forceExtension: true,
+    args: [],
+    columns: ['status', 'message'],
+    func: async (page) => {
+        if (!page)
+            throw new Error('Browser page required');
+        if (process.env.OPENCLI_VERBOSE) {
+            console.error('[opencli:v2ex] Navigating to /mission/daily');
+        }
+        await page.goto('https://www.v2ex.com/mission/daily');
+        // Cloudflare challenge bypass wait
+        for (let i = 0; i < 5; i++) {
+            await new Promise(r => setTimeout(r, 1500));
+            const title = await page.evaluate(`() => document.title`);
+            if (!title?.includes('Just a moment'))
+                break;
+            if (process.env.OPENCLI_VERBOSE)
+                console.error('[opencli:v2ex] Waiting for Cloudflare...');
+        }
+        // Evaluate DOM to find if we need to check in
+        const checkResult = await page.evaluate(`
+      async () => {
+        const btn = document.querySelector('input.super.normal.button');
+        if (!btn || !btn.value.includes('领取')) {
+          return { claimed: true, message: '今日奖励已发/无需领取' };
+        }
+        
+        const onclick = btn.getAttribute('onclick');
+        if (onclick) {
+          const match = onclick.match(/once=(\\d+)/);
+          if (match) {
+            return { claimed: false, once: match[1], message: btn.value };
+          }
+        }
+        
+        return { 
+          claimed: false, 
+          error: '找到了按钮，但未能提取 once token',
+          debug_title: document.title,
+          debug_body: document.body.innerText.substring(0, 200).replace(/\\n/g, ' ')
+        };
+      }
+    `);
+        if (checkResult.error) {
+            if (process.env.OPENCLI_VERBOSE) {
+                console.error(`[opencli:v2ex:debug] Page Title: ${checkResult.debug_title}`);
+                console.error(`[opencli:v2ex:debug] Page Body: ${checkResult.debug_body}`);
+            }
+            throw new Error(checkResult.error);
+        }
+        if (checkResult.claimed) {
+            return [{ status: '✅ 已签到', message: checkResult.message }];
+        }
+        // Perform check in
+        if (process.env.OPENCLI_VERBOSE) {
+            console.error(`[opencli:v2ex] Found check-in token: once=${checkResult.once}. Checking in...`);
+        }
+        await page.goto(`https://www.v2ex.com/mission/daily/redeem?once=${checkResult.once}`);
+        await new Promise(resolve => setTimeout(resolve, 3000)); // wait longer for redirect
+        // Verify result
+        const verifyResult = await page.evaluate(`
+      async () => {
+        const btn = document.querySelector('input.super.normal.button');
+        if (!btn || !btn.value.includes('领取')) {
+          // fetch balance to show user
+          let balance = '';
+          const balanceLink = document.querySelector('a.balance_area');
+          if (balanceLink) {
+            balance = Array.from(balanceLink.childNodes)
+                           .filter(n => n.nodeType === 3)
+                           .map(n => n.textContent?.trim())
+                           .join(' ')
+                           .trim();
+          }
+          return { success: true, balance };
+        }
+        return { success: false };
+      }
+    `);
+        if (verifyResult.success) {
+            return [{ status: '🎉 签到成功', message: `当前余额: ${verifyResult.balance || '未知'}` }];
+        }
+        else {
+            return [{ status: '❌ 签到失败', message: '未能确认签到结果，请手动检查' }];
+        }
+    },
+});

package/dist/clis/v2ex/me.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/v2ex/me.js

@@ -0,0 +1,99 @@
+/**
+ * V2EX Me (Profile/Balance) adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'v2ex',
+    name: 'me',
+    description: 'V2EX 获取个人资料 (余额/未读提醒)',
+    domain: 'www.v2ex.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    forceExtension: true,
+    args: [],
+    columns: ['username', 'balance', 'unread_notifications', 'daily_reward_ready'],
+    func: async (page) => {
+        if (!page)
+            throw new Error('Browser page required');
+        if (process.env.OPENCLI_VERBOSE) {
+            console.error('[opencli:v2ex] Navigating to /');
+        }
+        await page.goto('https://www.v2ex.com/');
+        // Cloudflare challenge bypass wait
+        for (let i = 0; i < 5; i++) {
+            await new Promise(r => setTimeout(r, 1500));
+            const title = await page.evaluate(`() => document.title`);
+            if (!title?.includes('Just a moment'))
+                break;
+            if (process.env.OPENCLI_VERBOSE)
+                console.error('[opencli:v2ex] Waiting for Cloudflare...');
+        }
+        // Evaluate DOM to extract user profile
+        const data = await page.evaluate(`
+      async () => {
+        let username = 'Unknown';
+        const navLinks = Array.from(document.querySelectorAll('a.top')).map(a => a.textContent?.trim());
+        if (navLinks.length > 1 && navLinks[0] === '首页') {
+          username = navLinks[1] || 'Unknown';
+        }
+        
+        if (username === 'Unknown') {
+          // Fallback check just in case
+          const profileEl = document.querySelector('a[href^="/member/"]');
+          if (profileEl && profileEl.textContent && profileEl.textContent.trim().length > 0) {
+            username = profileEl.textContent.trim();
+          }
+        }
+
+        let balance = '0';
+        const balanceLink = document.querySelector('a.balance_area');
+        if (balanceLink) {
+          balance = Array.from(balanceLink.childNodes)
+                         .filter(n => n.nodeType === 3)
+                         .map(n => n.textContent?.trim())
+                         .join(' ')
+                         .trim();
+        }
+
+        let unread_notifications = '0';
+        const notesEl = document.querySelector('a[href="/notifications"]');
+        if (notesEl) {
+          const text = notesEl.textContent?.trim() || '';
+          const match = text.match(/(\\d+)\\s*未读提醒/);
+          if (match) {
+            unread_notifications = match[1];
+          }
+        }
+
+        let daily_reward_ready = false;
+        const dailyEl = document.querySelector('a[href^="/mission/daily"]');
+        if (dailyEl && dailyEl.textContent?.includes('领取今日的登录奖励')) {
+          daily_reward_ready = true;
+        }
+
+        if (username === 'Unknown') {
+          return { 
+            error: '请先登录 V2EX（可能是 Cookie 未配置或已失效）',
+            debug_title: document.title,
+            debug_body: document.body.innerText.substring(0, 200).replace(/\\n/g, ' ')
+          };
+        }
+
+        return {
+          username,
+          balance,
+          unread_notifications,
+          daily_reward_ready: daily_reward_ready ? '是' : '否'
+        };
+      }
+    `);
+        if (data.error) {
+            if (process.env.OPENCLI_VERBOSE) {
+                console.error(`[opencli:v2ex:debug] Page Title: ${data.debug_title}`);
+                console.error(`[opencli:v2ex:debug] Page Body: ${data.debug_body}`);
+            }
+            throw new Error(data.error);
+        }
+        return [data];
+    },
+});

package/dist/clis/v2ex/notifications.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/v2ex/notifications.js

@@ -0,0 +1,72 @@
+/**
+ * V2EX Notifications adapter.
+ */
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'v2ex',
+    name: 'notifications',
+    description: 'V2EX 获取提醒 (回复/由于)',
+    domain: 'www.v2ex.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    forceExtension: true,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Number of notifications' }
+    ],
+    columns: ['type', 'content', 'time'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Browser page required');
+        if (process.env.OPENCLI_VERBOSE) {
+            console.error('[opencli:v2ex] Navigating to /notifications');
+        }
+        await page.goto('https://www.v2ex.com/notifications');
+        await new Promise(r => setTimeout(r, 1500)); // waitForLoadState doesn't always work robustly
+        // Evaluate DOM to extract notifications
+        const data = await page.evaluate(`
+      async () => {
+        const items = Array.from(document.querySelectorAll('#Main .box .cell[id^="n_"]'));
+        return items.map(item => {
+          let type = '通知';
+          let time = '';
+          
+          // determine type based on text content
+          const text = item.textContent || '';
+          if (text.includes('回复了你')) type = '回复';
+          else if (text.includes('感谢了你')) type = '感谢';
+          else if (text.includes('收藏了你')) type = '收藏';
+          else if (text.includes('提及你')) type = '提及';
+
+          const timeEl = item.querySelector('.snow');
+          if (timeEl) {
+            time = timeEl.textContent?.trim() || '';
+          }
+
+          // payload contains the actual reply text if any
+          let payload = '';
+          const payloadEl = item.querySelector('.payload');
+          if (payloadEl) {
+            payload = payloadEl.textContent?.trim() || '';
+          }
+
+          // fallback to full text cleaning if no payload (e.g. for favorites/thanks)
+          let content = payload;
+          if (!content) {
+            content = text.replace(/\\s+/g, ' ').trim();
+            // strip out time from content if present
+            if (time && content.includes(time)) {
+              content = content.replace(time, '').trim();
+            }
+          }
+
+          return { type, content, time };
+        });
+      }
+    `);
+        if (!Array.isArray(data)) {
+            throw new Error('Failed to parse notifications data');
+        }
+        const limit = kwargs.limit || 20;
+        return data.slice(0, limit);
+    },
+});

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

@@ -1,5 +1,8 @@
 /**
- * Xiaohongshu search — trigger search via Pinia store + XHR interception.
- * Inspired by bb-sites/xiaohongshu/search.js but adapted for opencli pipeline.
+ * Xiaohongshu search — DOM-based extraction from search results page.
+ * The previous Pinia store + XHR interception approach broke because
+ * the API now returns empty items. This version navigates directly to
+ * the search results page and extracts data from rendered DOM elements.
+ * Ref: https://github.com/jackwener/opencli/issues/10
  */
 export {};

package/dist/clis/xiaohongshu/search.js

@@ -1,6 +1,9 @@
 /**
- * Xiaohongshu search — trigger search via Pinia store + XHR interception.
- * Inspired by bb-sites/xiaohongshu/search.js but adapted for opencli pipeline.
+ * Xiaohongshu search — DOM-based extraction from search results page.
+ * The previous Pinia store + XHR interception approach broke because
+ * the API now returns empty items. This version navigates directly to
+ * the search results page and extracts data from rendered DOM elements.
+ * Ref: https://github.com/jackwener/opencli/issues/10
  */
 import { cli, Strategy } from '../../registry.js';
 cli({
@@ -13,54 +16,45 @@ cli({
         { name: 'keyword', required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
     ],
-    columns: ['rank', 'title', 'author', 'likes', 'type'],
+    columns: ['rank', 'title', 'author', 'likes'],
     func: async (page, kwargs) => {
-        await page.goto('https://www.xiaohongshu.com');
-        await page.wait(2);
+        const keyword = encodeURIComponent(kwargs.keyword);
+        await page.goto(`https://www.xiaohongshu.com/search_result?keyword=${keyword}&source=web_search_result_notes`);
+        await page.wait(3);
+        // Scroll a couple of times to load more results
+        await page.autoScroll({ times: 2 });
         const data = await page.evaluate(`
-      (async () => {
-        const app = document.querySelector('#app')?.__vue_app__;
-        const pinia = app?.config?.globalProperties?.$pinia;
-        if (!pinia?._s) return {error: 'Page not ready'};
+      (() => {
+        const notes = document.querySelectorAll('section.note-item');
+        const results = [];
+        notes.forEach(el => {
+          // Skip "related searches" sections
+          if (el.classList.contains('query-note-item')) return;
 
-        const searchStore = pinia._s.get('search');
-        if (!searchStore) return {error: 'Search store not found'};
+          const titleEl = el.querySelector('.title, .note-title, a.title');
+          const nameEl = el.querySelector('.name, .author-name, .nick-name');
+          const likesEl = el.querySelector('.count, .like-count, .like-wrapper .count');
+          const linkEl = el.querySelector('a[href*="/explore/"], a[href*="/search_result/"], a[href*="/note/"]');
 
-        let captured = null;
-        const origOpen = XMLHttpRequest.prototype.open;
-        const origSend = XMLHttpRequest.prototype.send;
-        XMLHttpRequest.prototype.open = function(m, u) { this.__url = u; return origOpen.apply(this, arguments); };
-        XMLHttpRequest.prototype.send = function(b) {
-          if (this.__url?.includes('search/notes')) {
-            const x = this;
-            const orig = x.onreadystatechange;
-            x.onreadystatechange = function() { if (x.readyState === 4 && !captured) { try { captured = JSON.parse(x.responseText); } catch {} } if (orig) orig.apply(this, arguments); };
-          }
-          return origSend.apply(this, arguments);
-        };
+          const href = linkEl?.getAttribute('href') || '';
+          const noteId = href.match(/\\/(?:explore|note)\\/([a-f0-9]+)/)?.[1] || '';
 
-        try {
-          searchStore.mutateSearchValue('${kwargs.keyword}');
-          await searchStore.loadMore();
-          await new Promise(r => setTimeout(r, 800));
-        } finally {
-          XMLHttpRequest.prototype.open = origOpen;
-          XMLHttpRequest.prototype.send = origSend;
-        }
-
-        if (!captured?.success) return {error: captured?.msg || 'Search failed'};
-        return (captured.data?.items || []).map(i => ({
-          title: i.note_card?.display_title || '',
-          type: i.note_card?.type || '',
-          url: 'https://www.xiaohongshu.com/explore/' + i.id,
-          author: i.note_card?.user?.nickname || '',
-          likes: i.note_card?.interact_info?.liked_count || '0',
-        }));
+          results.push({
+            title: (titleEl?.textContent || '').trim(),
+            author: (nameEl?.textContent || '').trim(),
+            likes: (likesEl?.textContent || '0').trim(),
+            url: noteId ? 'https://www.xiaohongshu.com/explore/' + noteId : '',
+          });
+        });
+        return results;
       })()
     `);
         if (!Array.isArray(data))
             return [];
-        return data.slice(0, kwargs.limit).map((item, i) => ({
+        return data
+            .filter((item) => item.title)
+            .slice(0, kwargs.limit)
+            .map((item, i) => ({
             rank: i + 1,
             ...item,
         }));