@jackwener/opencli 1.0.0 → 1.0.3

package/dist/clis/twitter/accept.js

@@ -0,0 +1,202 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'accept',
+    description: 'Auto-accept DM requests containing specific keywords',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
+    args: [
+        { name: 'keyword', type: 'string', required: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
+        { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+    ],
+    columns: ['index', 'status', 'user', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        const keywords = kwargs.keyword.split(',').map((k) => k.trim()).filter(Boolean);
+        const maxAccepts = kwargs.max ?? 20;
+        const results = [];
+        let acceptCount = 0;
+        // Track already-visited conversations to avoid infinite loops
+        const visited = new Set();
+        for (let round = 0; round < maxAccepts + 50; round++) {
+            if (acceptCount >= maxAccepts)
+                break;
+            // Step 1: Navigate to DM requests page
+            await page.goto('https://x.com/messages/requests');
+            await page.wait(4);
+            // Step 2: Get conversations with scroll-to-load
+            const convInfo = await page.evaluate(`(async () => {
+        try {
+          // Wait for initial items
+          let attempts = 0;
+          while (attempts < 10) {
+            const convs = document.querySelectorAll('[data-testid="conversation"]');
+            if (convs.length > 0) break;
+            await new Promise(r => setTimeout(r, 1000));
+            attempts++;
+          }
+
+          // Scroll to load more
+          const seenCount = new Set();
+          let noNewCount = 0;
+          for (let scroll = 0; scroll < 20; scroll++) {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const prevSize = seenCount.size;
+            convs.forEach((_, i) => seenCount.add(i));
+            if (convs.length >= ${maxAccepts + 10}) break;
+
+            // Scroll last item into view
+            if (convs.length > 0) {
+              convs[convs.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+            }
+            await new Promise(r => setTimeout(r, 1500));
+
+            if (seenCount.size <= prevSize) {
+              noNewCount++;
+              if (noNewCount >= 3) break;
+            } else {
+              noNewCount = 0;
+            }
+          }
+
+          const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+          if (convs.length === 0) return { ok: false, count: 0, items: [] };
+
+          const items = convs.map((conv, idx) => {
+            const text = conv.innerText || '';
+            const link = conv.querySelector('a[href]');
+            const href = link ? link.href : '';
+            const lines = text.split('\\n').filter(l => l.trim());
+            const user = lines[0] || 'Unknown';
+            return { idx, text, href, user };
+          });
+          return { ok: true, count: convs.length, items };
+        } catch(e) {
+          return { ok: false, error: String(e), count: 0, items: [] };
+        }
+      })()`);
+            if (!convInfo?.ok || convInfo.count === 0) {
+                if (results.length === 0) {
+                    results.push({ index: 1, status: 'info', user: 'System', message: 'No message requests found' });
+                }
+                break;
+            }
+            let foundInThisRound = false;
+            // Step 3: Find first unvisited conversation with keyword match in preview
+            for (const item of convInfo.items) {
+                if (acceptCount >= maxAccepts)
+                    break;
+                const convKey = item.href || `conv-${item.idx}`;
+                if (visited.has(convKey))
+                    continue;
+                visited.add(convKey);
+                // Check if preview text contains any keyword
+                const previewMatch = keywords.some((k) => item.text.includes(k));
+                if (!previewMatch)
+                    continue;
+                // Step 4: Click this conversation to open it
+                const clickResult = await page.evaluate(`(async () => {
+          try {
+            const convs = Array.from(document.querySelectorAll('[data-testid="conversation"]'));
+            const conv = convs[${item.idx}];
+            if (!conv) return { ok: false, error: 'Conversation element not found' };
+            conv.click();
+            await new Promise(r => setTimeout(r, 2000));
+            return { ok: true };
+          } catch(e) {
+            return { ok: false, error: String(e) };
+          }
+        })()`);
+                if (!clickResult?.ok)
+                    continue;
+                // Wait for conversation to load
+                await page.wait(2);
+                // Step 5: Read full chat content and find Accept button
+                const res = await page.evaluate(`(async () => {
+          try {
+            const keywords = ${JSON.stringify(keywords)};
+
+            // Get username from conversation header
+            const heading = document.querySelector('[data-testid="conversation-header"]') ||
+                            document.querySelector('[data-testid="DM-conversation-header"]');
+            let username = 'Unknown';
+            if (heading) {
+              username = heading.innerText.trim().split('\\n')[0];
+            }
+
+            // Read full chat area text
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('[data-testid="DMConversationBody"]') ||
+                             document.querySelector('main [data-testid="cellInnerDiv"]')?.closest('section') ||
+                             document.querySelector('main');
+            const text = chatArea ? chatArea.innerText : '';
+
+            // Verify keyword match in full chat content
+            const matchedKw = keywords.filter(k => text.includes(k));
+            if (matchedKw.length === 0) {
+              return { status: 'skipped', user: username, message: 'No keyword match in full content' };
+            }
+
+            // Find the Accept button
+            const allBtns = Array.from(document.querySelectorAll('[role="button"]'));
+            const acceptBtn = allBtns.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return t === 'accept' || t === '接受';
+            });
+
+            if (!acceptBtn) {
+              return { status: 'no_button', user: username, message: 'Keyword matched but no Accept button (already accepted?)' };
+            }
+
+            // Click Accept
+            acceptBtn.click();
+            await new Promise(r => setTimeout(r, 2000));
+
+            // Check for confirmation dialog
+            const btnsAfter = Array.from(document.querySelectorAll('[role="button"]'));
+            const confirmBtn = btnsAfter.find(btn => {
+              const t = btn.innerText.trim().toLowerCase();
+              return (t === 'accept' || t === '接受') && btn !== acceptBtn;
+            });
+            if (confirmBtn) {
+              confirmBtn.click();
+              await new Promise(r => setTimeout(r, 1000));
+            }
+
+            return { status: 'accepted', user: username, message: 'Accepted! Matched: ' + matchedKw.join(', ') };
+          } catch(e) {
+            return { status: 'error', user: 'system', message: String(e) };
+          }
+        })()`);
+                if (res?.status === 'accepted') {
+                    acceptCount++;
+                    foundInThisRound = true;
+                    results.push({
+                        index: acceptCount,
+                        status: 'accepted',
+                        user: res.user || 'Unknown',
+                        message: res.message || 'Accepted',
+                    });
+                    // After accept, Twitter redirects to /messages — loop back to /messages/requests
+                    await page.wait(2);
+                    break; // break inner loop, outer loop will re-navigate to requests
+                }
+                else if (res?.status === 'no_button') {
+                    // Already accepted, skip
+                    continue;
+                }
+            }
+            // If no match found in this round, we've exhausted all visible requests
+            if (!foundInThisRound) {
+                break;
+            }
+        }
+        if (results.length === 0) {
+            results.push({ index: 0, status: 'info', user: 'System', message: `No requests matched keywords "${keywords.join(', ')}"` });
+        }
+        return results;
+    }
+});

package/dist/clis/twitter/followers.js

@@ -13,10 +13,9 @@ cli({
     columns: ['screen_name', 'name', 'bio', 'followers'],
     func: async (page, kwargs) => {
         let targetUser = kwargs.user;
-        // If no user is specified, we must figure out the logged-in user's handle
+        // If no user is specified, figure out the logged-in user's handle
         if (!targetUser) {
             await page.goto('https://x.com/home');
-            // wait for home page navigation
             await page.wait(5);
             const href = await page.evaluate(`() => {
             const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
@@ -27,34 +26,44 @@ cli({
             }
             targetUser = href.replace('/', '');
         }
-        // 1. Navigate to user profile page
+        // 1. Navigate to profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Inject interceptor for the followers GraphQL API
+        // 2. Install interceptor BEFORE SPA navigation.
+        //    goto() resets JS context, but SPA click preserves it.
         await page.installInterceptor('Followers');
-        // 3. Click the followers link inside the profile page
-        await page.evaluate(`() => {
-        const target = '${targetUser}';
-        const link = document.querySelector('a[href="/' + target + '/followers"]');
-        if (link) link.click();
+        // 3. Click the followers link via SPA navigation (preserves interceptor).
+        //    Twitter uses /verified_followers instead of /followers now.
+        const safeUser = JSON.stringify(targetUser);
+        const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
+        const selectors = [
+            'a[href="/' + target + '/verified_followers"]',
+            'a[href="/' + target + '/followers"]',
+        ];
+        for (const sel of selectors) {
+            const link = document.querySelector(sel);
+            if (link) { link.click(); return true; }
+        }
+        return false;
     }`);
-        await page.wait(3);
-        // 4. Trigger API by scrolling
+        if (!clicked) {
+            throw new Error('Could not find followers link on profile page. Twitter may have changed the layout.');
+        }
+        await page.wait(5);
+        // 4. Scroll to trigger pagination API calls
         await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
-        // 4. Retrieve data from opencli's registered interceptors
-        const allRequests = await page.getInterceptedRequests();
-        const requestList = Array.isArray(allRequests) ? allRequests : [];
+        // 5. Retrieve intercepted data
+        const requests = await page.getInterceptedRequests();
+        const requestList = Array.isArray(requests) ? requests : [];
         if (requestList.length === 0) {
             return [];
         }
-        const requests = requestList.filter((r) => r?.url?.includes('Followers'));
-        if (!requests || requests.length === 0) {
-            return [];
-        }
         let results = [];
-        for (const req of requests) {
+        for (const req of requestList) {
             try {
-                let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
                 if (!instructions)
                     continue;
                 let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
@@ -69,7 +78,6 @@ cli({
                     const item = entry.content?.itemContent?.user_results?.result;
                     if (!item || item.__typename !== 'User')
                         continue;
-                    // Twitter GraphQL sometimes nests `core` differently depending on the endpoint profile state
                     const core = item.core || {};
                     const legacy = item.legacy || {};
                     results.push({
@@ -84,7 +92,7 @@ cli({
                 // ignore parsing errors for individual payloads
             }
         }
-        // Deduplicate by screen_name in case multiple scrolls caught the same
+        // Deduplicate by screen_name
         const unique = new Map();
         results.forEach(r => unique.set(r.screen_name, r));
         const deduplicatedResults = Array.from(unique.values());

package/dist/clis/twitter/following.js

@@ -13,10 +13,9 @@ cli({
     columns: ['screen_name', 'name', 'bio', 'followers'],
     func: async (page, kwargs) => {
         let targetUser = kwargs.user;
-        // If no user is specified, we must figure out the logged-in user's handle
+        // If no user is specified, figure out the logged-in user's handle
         if (!targetUser) {
             await page.goto('https://x.com/home');
-            // wait for home page navigation
             await page.wait(5);
             const href = await page.evaluate(`() => {
             const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
@@ -27,21 +26,27 @@ cli({
             }
             targetUser = href.replace('/', '');
         }
-        // 1. Navigate to user profile page
+        // 1. Navigate to profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Inject interceptor for Following GraphQL API
+        // 2. Install interceptor BEFORE SPA navigation.
+        //    goto() resets JS context, but SPA click preserves it.
         await page.installInterceptor('Following');
-        // 3. Click the following link inside the profile page
-        await page.evaluate(`() => {
-        const target = '${targetUser}';
+        // 3. Click the following link via SPA navigation (preserves interceptor)
+        const safeUser = JSON.stringify(targetUser);
+        const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
         const link = document.querySelector('a[href="/' + target + '/following"]');
-        if (link) link.click();
+        if (link) { link.click(); return true; }
+        return false;
     }`);
-        await page.wait(3);
-        // 4. Trigger API by scrolling
+        if (!clicked) {
+            throw new Error('Could not find following link on profile page. Twitter may have changed the layout.');
+        }
+        await page.wait(5);
+        // 4. Scroll to trigger pagination API calls
         await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
-        // 4. Retrieve data from opencli's registered interceptors
+        // 5. Retrieve intercepted data
         const requests = await page.getInterceptedRequests();
         const requestList = Array.isArray(requests) ? requests : [];
         if (requestList.length === 0) {
@@ -50,7 +55,8 @@ cli({
         let results = [];
         for (const req of requestList) {
             try {
-                let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
                 if (!instructions)
                     continue;
                 let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
@@ -65,7 +71,6 @@ cli({
                     const item = entry.content?.itemContent?.user_results?.result;
                     if (!item || item.__typename !== 'User')
                         continue;
-                    // Twitter GraphQL sometimes nests `core` differently depending on the endpoint profile state
                     const core = item.core || {};
                     const legacy = item.legacy || {};
                     results.push({
@@ -80,7 +85,7 @@ cli({
                 // ignore parsing errors for individual payloads
             }
         }
-        // Deduplicate by screen_name in case multiple scrolls caught the same
+        // Deduplicate by screen_name
         const unique = new Map();
         results.forEach(r => unique.set(r.screen_name, r));
         const deduplicatedResults = Array.from(unique.values());

package/dist/clis/twitter/notifications.js

@@ -11,17 +11,25 @@ cli({
     ],
     columns: ['id', 'action', 'author', 'text', 'url'],
     func: async (page, kwargs) => {
-        // Install the interceptor before loading the notifications page so we
-        // capture the initial timeline request triggered during page load.
-        await page.goto('https://x.com');
-        await page.wait(2);
+        // 1. Navigate to home first (we need a loaded Twitter page for SPA navigation)
+        await page.goto('https://x.com/home');
+        await page.wait(3);
+        // 2. Install interceptor BEFORE SPA navigation
         await page.installInterceptor('NotificationsTimeline');
-        // 1. Navigate to notifications
-        await page.goto('https://x.com/notifications');
+        // 3. SPA navigate to notifications via history API
+        await page.evaluate(`() => {
+        window.history.pushState({}, '', '/notifications');
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    }`);
         await page.wait(5);
-        // 3. Trigger API by scrolling (if we need to load more)
+        // Verify SPA navigation succeeded
+        const currentUrl = await page.evaluate('() => window.location.pathname');
+        if (currentUrl !== '/notifications') {
+            throw new Error('SPA navigation to notifications failed. Twitter may have changed its routing.');
+        }
+        // 4. Scroll to trigger pagination
         await page.autoScroll({ times: 2, delayMs: 2000 });
-        // 4. Retrieve data
+        // 5. Retrieve data
         const requests = await page.getInterceptedRequests();
         if (!requests || requests.length === 0)
             return [];
@@ -29,18 +37,18 @@ cli({
         const seen = new Set();
         for (const req of requests) {
             try {
+                // GraphQL response: { data: { viewer: ... } } (one level of .data)
                 let instructions = [];
-                if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
-                    instructions = req.data.data.viewer.timeline_response.timeline.instructions;
+                if (req.data?.viewer?.timeline_response?.timeline?.instructions) {
+                    instructions = req.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?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
+                    instructions = req.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
                 }
-                else if (req.data?.data?.timeline?.instructions) {
-                    instructions = req.data.data.timeline.instructions;
+                else if (req.data?.timeline?.instructions) {
+                    instructions = req.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));
                 }
@@ -60,20 +68,18 @@ cli({
                 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 || '';
                         const fromUser = item.template?.from_users?.[0]?.user_results?.result;
-                        author = fromUser?.legacy?.screen_name || fromUser?.core?.screen_name || 'unknown';
+                        // Twitter moved screen_name from legacy to core
+                        author = fromUser?.core?.screen_name || fromUser?.legacy?.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) {
                             const targetText = targetTweet.note_tweet?.note_tweet_results?.result?.text || targetTweet.legacy?.full_text || '';
@@ -84,15 +90,16 @@ cli({
                         }
                     }
                     else if (item.__typename === 'TweetNotification') {
-                        // Direct mention/reply
                         const tweet = item.tweet_result?.result;
-                        author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                        const tweetUser = tweet?.core?.user_results?.result;
+                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                         text = tweet?.note_tweet?.note_tweet_results?.result?.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';
+                        const tweetUser = item.core?.user_results?.result;
+                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                         text = item.note_tweet?.note_tweet_results?.result?.text || item.legacy?.full_text || '';
                         actionText = 'Mention';
                         urlStr = `https://x.com/i/status/${item.rest_id}`;

package/dist/clis/twitter/post.js

@@ -23,8 +23,15 @@ cli({
             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)});
+                // Simulate a paste event to properly handle newlines in Draft.js/React
+                const textToInsert = ${JSON.stringify(kwargs.text)};
+                const dataTransfer = new DataTransfer();
+                dataTransfer.setData('text/plain', textToInsert);
+                box.dispatchEvent(new ClipboardEvent('paste', {
+                    clipboardData: dataTransfer,
+                    bubbles: true,
+                    cancelable: true
+                }));
             } else {
                 return { ok: false, message: 'Could not find the tweet composer text area.' };
             }

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

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