@jackwener/opencli 0.4.2 → 0.4.4

package/dist/clis/twitter/delete.js

@@ -0,0 +1,73 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'delete',
+    description: 'Delete a specific tweet by URL',
+    domain: 'x.com',
+    strategy: Strategy.UI, // Utilizes internal DOM flows for interaction
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to delete' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        console.log(`Navigating to tweet: ${kwargs.url}`);
+        await page.goto(kwargs.url);
+        await page.wait(5); // Wait for tweet to load completely
+        const result = await page.evaluate(`(async () => {
+        try {
+            // Wait for caret button (which has 'More' aria-label) within the main tweet body
+            // Getting the first 'More' usually corresponds to the main displayed tweet of the URL
+            const moreMenu = document.querySelector('[aria-label="More"]');
+            if (!moreMenu) {
+                return { ok: false, message: 'Could not find the "More" context menu on this tweet. Are you sure you are logged in and looking at a valid tweet?' };
+            }
+
+            // Click the 'More' 3 dots button to open the dropdown menu
+            moreMenu.click();
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Wait for dropdown pop-out to appear and look for the 'Delete' option
+            const items = document.querySelectorAll('[role="menuitem"]');
+            let deleteBtn = null;
+            for (const item of items) {
+                if (item.textContent.includes('Delete') && !item.textContent.includes('List')) {
+                    deleteBtn = item;
+                    break;
+                }
+            }
+            
+            if (!deleteBtn) {
+                // If there's no Delete button, it's not our tweet OR localization is not English.
+                // Assuming English default for now.
+                return { ok: false, message: 'This tweet does not seem to belong to you, or the Delete option is missing (not your tweet).' };
+            }
+
+            // Click Delete
+            deleteBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Find and click the confirmation 'Delete' prompt inside the modal
+            const confirmBtn = document.querySelector('[data-testid="confirmationSheetConfirm"]');
+            if (confirmBtn) {
+                confirmBtn.click();
+                return { ok: true, message: 'Tweet successfully deleted.' };
+            } else {
+                return { ok: false, message: 'Delete confirmation dialog did not appear.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the deletion request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

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

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

package/dist/clis/twitter/followers.js

@@ -0,0 +1,104 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'followers',
+    description: 'Get accounts following a Twitter/X user',
+    domain: 'x.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'user', type: 'string', required: false },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    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 (!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"]');
+            return link ? link.getAttribute('href') : null;
+        }`);
+            if (!href) {
+                throw new Error('Could not find logged-in user profile link. Are you logged in?');
+            }
+            targetUser = href.replace('/', '');
+        }
+        // 1. Navigate to user profile page
+        await page.goto(`https://x.com/${targetUser}`);
+        await page.wait(3);
+        // 2. Inject interceptor for Followers GraphQL API (or user_flow.json)
+        await page.installInterceptor('graphql');
+        // 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();
+    }`);
+        await page.wait(3);
+        // 4. Trigger API by scrolling
+        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
+        // 4. Retrieve data from opencli's registered interceptors
+        const allRequests = await page.getInterceptedRequests();
+        // Debug: Force dump all intercepted XHRs that match followers
+        if (!allRequests || allRequests.length === 0) {
+            console.log('No GraphQL requests captured by the interceptor backend.');
+            return [];
+        }
+        console.log('Intercepted keys:', allRequests.map((r) => {
+            try {
+                const u = new URL(r.url);
+                return u.pathname;
+            }
+            catch (e) {
+                return r.url;
+            }
+        }));
+        const requests = allRequests.filter((r) => r.url.includes('Followers'));
+        if (!requests || requests.length === 0) {
+            console.log('No specific Followers requests captured. Check keys printed above.');
+            return [];
+        }
+        let results = [];
+        for (const req of requests) {
+            try {
+                let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+                if (!instructions)
+                    continue;
+                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
+                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('user-'))
+                        continue;
+                    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({
+                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
+                        name: core.name || legacy.name || 'unknown',
+                        bio: legacy.description || item.profile_bio?.description || '',
+                        followers: legacy.followers_count || legacy.normal_followers_count || 0
+                    });
+                }
+            }
+            catch (e) {
+                // ignore parsing errors for individual payloads
+            }
+        }
+        // Deduplicate by screen_name in case multiple scrolls caught the same
+        const unique = new Map();
+        results.forEach(r => unique.set(r.screen_name, r));
+        const deduplicatedResults = Array.from(unique.values());
+        return deduplicatedResults.slice(0, kwargs.limit);
+    }
+});

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

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

package/dist/clis/twitter/following.js

@@ -0,0 +1,90 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'following',
+    description: 'Get accounts a Twitter/X user is following',
+    domain: 'x.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'user', type: 'string', required: false },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    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 (!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"]');
+            return link ? link.getAttribute('href') : null;
+        }`);
+            if (!href) {
+                throw new Error('Could not find logged-in user profile link. Are you logged in?');
+            }
+            targetUser = href.replace('/', '');
+        }
+        // 1. Navigate to user profile page
+        await page.goto(`https://x.com/${targetUser}`);
+        await page.wait(3);
+        // 2. Inject interceptor for Following GraphQL API
+        await page.installInterceptor('Following');
+        // 3. Click the following link inside the profile page
+        await page.evaluate(`() => {
+        const target = '${targetUser}';
+        const link = document.querySelector('a[href="/' + target + '/following"]');
+        if (link) link.click();
+    }`);
+        await page.wait(3);
+        // 4. Trigger API by scrolling
+        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
+        // 4. Retrieve data from opencli's registered interceptors
+        const requests = await page.getInterceptedRequests();
+        // Debug: Force dump all intercepted XHRs that match following
+        if (!requests || requests.length === 0) {
+            console.log('No Following requests captured by the interceptor backend.');
+            return [];
+        }
+        let results = [];
+        for (const req of requests) {
+            try {
+                let instructions = req.data?.data?.user?.result?.timeline?.timeline?.instructions;
+                if (!instructions)
+                    continue;
+                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
+                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('user-'))
+                        continue;
+                    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({
+                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
+                        name: core.name || legacy.name || 'unknown',
+                        bio: legacy.description || item.profile_bio?.description || '',
+                        followers: legacy.followers_count || legacy.normal_followers_count || 0
+                    });
+                }
+            }
+            catch (e) {
+                // ignore parsing errors for individual payloads
+            }
+        }
+        // Deduplicate by screen_name in case multiple scrolls caught the same
+        const unique = new Map();
+        results.forEach(r => unique.set(r.screen_name, r));
+        const deduplicatedResults = Array.from(unique.values());
+        return deduplicatedResults.slice(0, kwargs.limit);
+    }
+});

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

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

package/dist/clis/twitter/like.js

@@ -0,0 +1,69 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'like',
+    description: 'Like a specific tweet',
+    domain: 'x.com',
+    strategy: Strategy.UI, // Utilizes internal DOM flows for interaction
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to like' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        console.log(`Navigating to tweet: ${kwargs.url}`);
+        await page.goto(kwargs.url);
+        await page.wait(5); // Wait for tweet to load completely
+        const result = await page.evaluate(`(async () => {
+        try {
+            // Poll for the tweet to render
+            let attempts = 0;
+            let likeBtn = null;
+            let unlikeBtn = null;
+            
+            while (attempts < 20) {
+                unlikeBtn = document.querySelector('[data-testid="unlike"]');
+                likeBtn = document.querySelector('[data-testid="like"]');
+                
+                if (unlikeBtn || likeBtn) break;
+                
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            // Check if it's already liked
+            if (unlikeBtn) {
+                return { ok: true, message: 'Tweet is already liked.' };
+            }
+
+            if (!likeBtn) {
+                return { ok: false, message: 'Could not find the Like button on this tweet after waiting 10 seconds. Are you logged in?' };
+            }
+
+            // Click Like
+            likeBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Verify success by checking if the 'unlike' button appeared
+            const verifyBtn = document.querySelector('[data-testid="unlike"]');
+            if (verifyBtn) {
+                return { ok: true, message: 'Tweet successfully liked.' };
+            } else {
+                return { ok: false, message: 'Like action was initiated but UI did not update as expected.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the like network request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

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

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

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 {};