@huyuan-ai/cli 1.0.0 → 1.0.2

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

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

package/vendor/opencli/dist/clis/twitter/notifications.js

@@ -0,0 +1,127 @@
+import { CommandExecutionError } from '../../errors.js';
+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 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');
+        // 3. SPA navigate to notifications via history API
+        await page.evaluate(`() => {
+        window.history.pushState({}, '', '/notifications');
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    }`);
+        await page.waitForCapture(5);
+        // Verify SPA navigation succeeded
+        const currentUrl = await page.evaluate('() => window.location.pathname');
+        if (currentUrl !== '/notifications') {
+            throw new CommandExecutionError('SPA navigation to notifications failed. Twitter may have changed its routing.');
+        }
+        // 4. Scroll to trigger pagination
+        await page.autoScroll({ times: 2, delayMs: 2000 });
+        // 5. Retrieve data
+        const requests = await page.getInterceptedRequests();
+        if (!requests || requests.length === 0)
+            return [];
+        let results = [];
+        const seen = new Set();
+        for (const req of requests) {
+            try {
+                // GraphQL response: { data: { viewer: ... } } (one level of .data)
+                let instructions = [];
+                if (req.data?.viewer?.timeline_response?.timeline?.instructions) {
+                    instructions = req.data.viewer.timeline_response.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?.timeline?.instructions) {
+                    instructions = req.data.timeline.instructions;
+                }
+                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('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;
+                    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') {
+                        text = item.rich_message?.text || item.message?.text || '';
+                        const fromUser = item.template?.from_users?.[0]?.user_results?.result;
+                        // 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';
+                        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 || '';
+                            text += text && targetText ? ' | ' + targetText : targetText;
+                            if (!urlStr) {
+                                urlStr = `https://x.com/i/status/${targetTweet.rest_id}`;
+                            }
+                        }
+                    }
+                    else if (item.__typename === 'TweetNotification') {
+                        const tweet = item.tweet_result?.result;
+                        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') {
+                        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}`;
+                    }
+                    const id = item.id || item.rest_id || entryId;
+                    if (seen.has(id))
+                        return;
+                    seen.add(id);
+                    results.push({
+                        id,
+                        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/vendor/opencli/dist/clis/twitter/post.d.ts

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

package/vendor/opencli/dist/clis/twitter/post.js

@@ -0,0 +1,98 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+const MAX_IMAGES = 4;
+const UPLOAD_POLL_MS = 500;
+const UPLOAD_TIMEOUT_MS = 30_000;
+const SUPPORTED_EXTENSIONS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp']);
+function validateImagePaths(raw) {
+    const paths = raw.split(',').map(s => s.trim()).filter(Boolean);
+    if (paths.length > MAX_IMAGES) {
+        throw new CommandExecutionError(`Too many images: ${paths.length} (max ${MAX_IMAGES})`);
+    }
+    return paths.map(p => {
+        const absPath = path.resolve(p);
+        const ext = path.extname(absPath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.has(ext)) {
+            throw new CommandExecutionError(`Unsupported image format "${ext}". Supported: jpg, png, gif, webp`);
+        }
+        const stat = fs.statSync(absPath, { throwIfNoEntry: false });
+        if (!stat || !stat.isFile()) {
+            throw new CommandExecutionError(`Not a valid file: ${absPath}`);
+        }
+        return absPath;
+    });
+}
+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, positional: true, help: 'The text content of the tweet' },
+        { name: 'images', type: 'string', required: false, help: 'Image paths, comma-separated, max 4 (jpg/png/gif/webp)' },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter post');
+        // Validate images upfront before any browser interaction
+        const absPaths = kwargs.images ? validateImagePaths(String(kwargs.images)) : [];
+        // 1. Navigate to compose modal
+        await page.goto('https://x.com/compose/tweet');
+        await page.wait(3);
+        // 2. Type the text via clipboard paste (handles newlines in Draft.js)
+        const typeResult = await page.evaluate(`(async () => {
+        try {
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            if (!box) return { ok: false, message: 'Could not find the tweet composer text area.' };
+            box.focus();
+            const dt = new DataTransfer();
+            dt.setData('text/plain', ${JSON.stringify(kwargs.text)});
+            box.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }));
+            return { ok: true };
+        } catch (e) { return { ok: false, message: String(e) }; }
+    })()`);
+        if (!typeResult.ok) {
+            return [{ status: 'failed', message: typeResult.message, text: kwargs.text }];
+        }
+        // 3. Attach images if provided
+        if (absPaths.length > 0) {
+            if (!page.setFileInput) {
+                throw new CommandExecutionError('Browser extension does not support file upload. Please update the extension.');
+            }
+            await page.setFileInput(absPaths, 'input[data-testid="fileInput"]');
+            // Poll until attachments render and tweet button is enabled
+            const pollIterations = Math.ceil(UPLOAD_TIMEOUT_MS / UPLOAD_POLL_MS);
+            const uploaded = await page.evaluate(`(async () => {
+          for (let i = 0; i < ${JSON.stringify(pollIterations)}; i++) {
+              await new Promise(r => setTimeout(r, ${JSON.stringify(UPLOAD_POLL_MS)}));
+              const container = document.querySelector('[data-testid="attachments"]');
+              if (!container) continue;
+              if (container.querySelectorAll('[role="group"]').length !== ${JSON.stringify(absPaths.length)}) continue;
+              const btn = document.querySelector('[data-testid="tweetButton"]') || document.querySelector('[data-testid="tweetButtonInline"]');
+              if (btn && !btn.disabled) return true;
+          }
+          return false;
+      })()`);
+            if (!uploaded) {
+                return [{ status: 'failed', message: `Image upload timed out (${UPLOAD_TIMEOUT_MS / 1000}s).`, text: kwargs.text }];
+            }
+        }
+        // 4. Click the post button
+        await page.wait(1);
+        const result = await page.evaluate(`(async () => {
+        try {
+            const btn = document.querySelector('[data-testid="tweetButton"]') || document.querySelector('[data-testid="tweetButtonInline"]');
+            if (btn && !btn.disabled) { btn.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: String(e) }; }
+    })()`);
+        if (result.ok)
+            await page.wait(3);
+        return [{ status: result.ok ? 'success' : 'failed', message: result.message, text: kwargs.text }];
+    }
+});

package/vendor/opencli/dist/clis/twitter/post.test.d.ts

@@ -0,0 +1 @@
+import './post.js';

package/vendor/opencli/dist/clis/twitter/post.test.js

@@ -0,0 +1,116 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './post.js';
+vi.mock('node:fs', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        statSync: vi.fn((p, _opts) => {
+            if (String(p).includes('missing'))
+                return undefined;
+            return { isFile: () => true };
+        }),
+    };
+});
+vi.mock('node:path', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        resolve: vi.fn((p) => `/abs/${p}`),
+        extname: vi.fn((p) => {
+            const m = p.match(/\.[^.]+$/);
+            return m ? m[0] : '';
+        }),
+    };
+});
+function makePage(overrides = {}) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn().mockResolvedValue({ ok: true }),
+        setFileInput: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}
+describe('twitter post command', () => {
+    const getCommand = () => getRegistry().get('twitter/post');
+    it('posts text-only tweet successfully', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true })
+                .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }),
+        });
+        const result = await command.func(page, { text: 'hello world' });
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'hello world' }]);
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/tweet');
+    });
+    it('returns failed when text area not found', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: false, message: 'Could not find the tweet composer text area.' }),
+        });
+        const result = await command.func(page, { text: 'hello' });
+        expect(result).toEqual([{ status: 'failed', message: 'Could not find the tweet composer text area.', text: 'hello' }]);
+    });
+    it('throws when more than 4 images', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'a.png,b.png,c.png,d.png,e.png' })).rejects.toThrow('Too many images: 5 (max 4)');
+    });
+    it('throws when image file does not exist', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toThrow('Not a valid file');
+    });
+    it('throws on unsupported image format', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'photo.bmp' })).rejects.toThrow('Unsupported image format');
+    });
+    it('throws when page.setFileInput is not available', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn().mockResolvedValueOnce({ ok: true }),
+            setFileInput: undefined,
+        });
+        await expect(command.func(page, { text: 'hi', images: 'a.png' })).rejects.toThrow('Browser extension does not support file upload');
+    });
+    it('posts with images when upload completes', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true }) // type text
+                .mockResolvedValueOnce(true) // upload polling returns true
+                .mockResolvedValueOnce({ ok: true, message: 'Tweet posted successfully.' }), // click post
+        });
+        const result = await command.func(page, { text: 'with images', images: 'a.png,b.png' });
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'with images' }]);
+        expect(page.setFileInput).toHaveBeenCalled();
+        const uploadScript = page.evaluate.mock.calls[1][0];
+        expect(uploadScript).toContain('[data-testid="attachments"]');
+        expect(uploadScript).toContain('[role="group"]');
+    });
+    it('returns failed when image upload times out', async () => {
+        const command = getCommand();
+        const page = makePage({
+            evaluate: vi.fn()
+                .mockResolvedValueOnce({ ok: true })
+                .mockResolvedValueOnce(false),
+        });
+        const result = await command.func(page, { text: 'timeout', images: 'a.png' });
+        expect(result).toEqual([{ status: 'failed', message: 'Image upload timed out (30s).', text: 'timeout' }]);
+    });
+    it('validates images before navigating to compose page', async () => {
+        const command = getCommand();
+        const page = makePage();
+        await expect(command.func(page, { text: 'hi', images: 'missing.png' })).rejects.toThrow('Not a valid file');
+        // Should NOT have navigated since validation happens first
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+    it('throws when no browser session', async () => {
+        const command = getCommand();
+        await expect(command.func(null, { text: 'hi' })).rejects.toThrow('Browser session required for twitter post');
+    });
+});

package/vendor/opencli/dist/clis/twitter/profile.d.ts

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

package/vendor/opencli/dist/clis/twitter/profile.js

@@ -0,0 +1,103 @@
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { resolveTwitterQueryId } from './shared.js';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+cli({
+    site: 'twitter',
+    name: 'profile',
+    description: 'Fetch a Twitter user profile (bio, stats, etc.)',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (without @). Defaults to logged-in user.' },
+    ],
+    columns: ['screen_name', 'name', 'bio', 'location', 'url', 'followers', 'following', 'tweets', 'likes', 'verified', 'created_at'],
+    func: async (page, kwargs) => {
+        let username = (kwargs.username || '').replace(/^@/, '');
+        // If no username, detect the logged-in user
+        if (!username) {
+            await page.goto('https://x.com/home');
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
+            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 AuthRequiredError('x.com', 'Could not detect logged-in user. Are you logged in?');
+            username = href.replace('/', '');
+        }
+        // Navigate directly to the user's profile page (gives us cookie context)
+        await page.goto(`https://x.com/${username}`);
+        await page.wait(3);
+        const queryId = await resolveTwitterQueryId(page, 'UserByScreenName', USER_BY_SCREEN_NAME_QUERY_ID);
+        const result = await page.evaluate(`
+      async () => {
+        const screenName = "${username}";
+        const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1];
+        if (!ct0) return {error: 'No ct0 cookie — not logged into x.com'};
+
+        const bearer = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+        const headers = {
+          'Authorization': 'Bearer ' + decodeURIComponent(bearer),
+          'X-Csrf-Token': ct0,
+          'X-Twitter-Auth-Type': 'OAuth2Session',
+          'X-Twitter-Active-User': 'yes'
+        };
+
+        const variables = JSON.stringify({
+          screen_name: screenName,
+          withSafetyModeUserFields: true,
+        });
+        const features = JSON.stringify({
+          hidden_profile_subscriptions_enabled: true,
+          rweb_tipjar_consumption_enabled: true,
+          responsive_web_graphql_exclude_directive_enabled: true,
+          verified_phone_label_enabled: false,
+          subscriptions_verification_info_is_identity_verified_enabled: true,
+          subscriptions_verification_info_verified_since_enabled: true,
+          highlights_tweets_tab_ui_enabled: true,
+          responsive_web_twitter_article_notes_tab_enabled: true,
+          subscriptions_feature_can_gift_premium: true,
+          creator_subscriptions_tweet_preview_api_enabled: true,
+          responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+          responsive_web_graphql_timeline_navigation_enabled: true,
+        });
+
+        const url = '/i/api/graphql/' + ${JSON.stringify(queryId)} + '/UserByScreenName?variables='
+          + encodeURIComponent(variables)
+          + '&features=' + encodeURIComponent(features);
+
+        const resp = await fetch(url, {headers, credentials: 'include'});
+        if (!resp.ok) return {error: 'HTTP ' + resp.status, hint: 'User may not exist or queryId expired'};
+        const d = await resp.json();
+
+        const result = d.data?.user?.result;
+        if (!result) return {error: 'User @' + screenName + ' not found'};
+
+        const legacy = result.legacy || {};
+        const expandedUrl = legacy.entities?.url?.urls?.[0]?.expanded_url || '';
+
+        return [{
+          screen_name: legacy.screen_name || screenName,
+          name: legacy.name || '',
+          bio: legacy.description || '',
+          location: legacy.location || '',
+          url: expandedUrl,
+          followers: legacy.followers_count || 0,
+          following: legacy.friends_count || 0,
+          tweets: legacy.statuses_count || 0,
+          likes: legacy.favourites_count || 0,
+          verified: result.is_blue_verified || legacy.verified || false,
+          created_at: legacy.created_at || '',
+        }];
+      }
+    `);
+        if (result?.error) {
+            if (String(result.error).includes('No ct0 cookie'))
+                throw new AuthRequiredError('x.com', result.error);
+            throw new CommandExecutionError(result.error + (result.hint ? ` (${result.hint})` : ''));
+        }
+        return result || [];
+    }
+});

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

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

package/vendor/opencli/dist/clis/twitter/reply-dm.js

@@ -0,0 +1,182 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'reply-dm',
+    description: 'Send a message to recent DM conversations',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 600, // 10 min — batch operation
+    args: [
+        { name: 'text', type: 'string', required: true, positional: true, help: 'Message text to send (e.g. "我的微信 wxkabi")' },
+        { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of conversations to reply to (default: 20)' },
+        { name: 'skip-replied', type: 'boolean', required: false, default: true, help: 'Skip conversations where you already sent the same text (default: true)' },
+    ],
+    columns: ['index', 'status', 'user', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter reply-dm');
+        const messageText = kwargs.text;
+        const maxSend = kwargs.max ?? 20;
+        const skipReplied = kwargs['skip-replied'] !== false;
+        const results = [];
+        let sentCount = 0;
+        // Step 1: Navigate to messages to get conversation list
+        await page.goto('https://x.com/messages');
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        // Step 2: Collect conversations with scroll-to-load
+        const needed = maxSend + 10; // extra buffer for skips
+        const convList = await page.evaluate(`(async () => {
+      try {
+        // Wait for initial items
+        let attempts = 0;
+        while (attempts < 10) {
+          const items = document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]');
+          if (items.length > 0) break;
+          await new Promise(r => setTimeout(r, 1000));
+          attempts++;
+        }
+
+        // Scroll to load more conversations
+        const needed = ${needed};
+        const seenIds = new Set();
+        let noNewCount = 0;
+
+        for (let scroll = 0; scroll < 30; scroll++) {
+          const items = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          items.forEach(el => seenIds.add(el.getAttribute('data-testid')));
+
+          if (seenIds.size >= needed) break;
+
+          // Find the scrollable container and scroll it
+          const scrollContainer = document.querySelector('[data-testid="dm-inbox-panel"]') ||
+                                  items[items.length - 1]?.closest('[class*="scroll"]') ||
+                                  items[items.length - 1]?.parentElement;
+          if (scrollContainer) {
+            scrollContainer.scrollTop = scrollContainer.scrollHeight;
+          }
+          // Also try scrolling the last item into view
+          if (items.length > 0) {
+            items[items.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+          }
+
+          await new Promise(r => setTimeout(r, 1500));
+
+          // Check if new items appeared
+          const newItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          const newIds = new Set(newItems.map(el => el.getAttribute('data-testid')));
+          if (newIds.size <= seenIds.size) {
+            noNewCount++;
+            if (noNewCount >= 3) break; // No more loading after 3 tries
+          } else {
+            noNewCount = 0;
+          }
+        }
+
+        // Collect all visible conversations
+        const finalItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+        const conversations = finalItems.map((item, idx) => {
+          const testId = item.getAttribute('data-testid') || '';
+          const text = item.innerText || '';
+          const lines = text.split('\\n').filter(l => l.trim());
+          const user = lines[0] || 'Unknown';
+          const match = testId.match(/dm-conversation-item-(.+)/);
+          const convId = match ? match[1].replace(':', '-') : '';
+          const link = item.querySelector('a[href*="/messages/"]');
+          const href = link ? link.href : '';
+          return { idx, user, convId, href, preview: text.substring(0, 100) };
+        });
+
+        return { ok: true, conversations, total: conversations.length };
+      } catch(e) {
+        return { ok: false, error: String(e), conversations: [], total: 0 };
+      }
+    })()`);
+        if (!convList?.ok || !convList.conversations?.length) {
+            return [{ index: 1, status: 'info', user: 'System', message: 'No conversations found' }];
+        }
+        const conversations = convList.conversations;
+        // Step 3: Iterate through conversations and send message
+        for (const conv of conversations) {
+            if (sentCount >= maxSend)
+                break;
+            const convUrl = conv.convId
+                ? `https://x.com/messages/${conv.convId}`
+                : conv.href;
+            if (!convUrl)
+                continue;
+            await page.goto(convUrl);
+            await page.wait(3);
+            const sendResult = await page.evaluate(`(async () => {
+        try {
+          const messageText = ${JSON.stringify(messageText)};
+          const skipReplied = ${skipReplied};
+
+          // Get username from conversation
+          const dmHeader = document.querySelector('[data-testid="DmActivityContainer"] [dir="ltr"] span') ||
+                           document.querySelector('[data-testid="conversation-header"]') ||
+                           document.querySelector('[data-testid="DmActivityContainer"] h2');
+          const username = dmHeader ? dmHeader.innerText.trim().split('\\\\n')[0] : '${conv.user}';
+
+          // Check if we already sent this message
+          if (skipReplied) {
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('main');
+            const chatText = chatArea ? chatArea.innerText : '';
+            if (chatText.includes(messageText)) {
+              return { status: 'skipped', user: username, message: 'Already sent this message' };
+            }
+          }
+
+          // Find the text input
+          const input = document.querySelector('[data-testid="dmComposerTextInput"]');
+          if (!input) {
+            return { status: 'error', user: username, message: 'No message input found' };
+          }
+
+          // Focus and type into the DraftEditor
+          input.focus();
+          await new Promise(r => setTimeout(r, 300));
+          document.execCommand('insertText', false, messageText);
+          await new Promise(r => setTimeout(r, 500));
+
+          // Click send button
+          const sendBtn = document.querySelector('[data-testid="dmComposerSendButton"]');
+          if (!sendBtn) {
+            return { status: 'error', user: username, message: 'No send button found' };
+          }
+
+          sendBtn.click();
+          await new Promise(r => setTimeout(r, 1500));
+
+          return { status: 'sent', user: username, message: 'Message sent: ' + messageText };
+        } catch(e) {
+          return { status: 'error', user: 'system', message: String(e) };
+        }
+      })()`);
+            if (sendResult?.status === 'sent') {
+                sentCount++;
+                results.push({
+                    index: sentCount,
+                    status: 'sent',
+                    user: sendResult.user || conv.user,
+                    message: sendResult.message,
+                });
+            }
+            else if (sendResult?.status === 'skipped') {
+                results.push({
+                    index: results.length + 1,
+                    status: 'skipped',
+                    user: sendResult.user || conv.user,
+                    message: sendResult.message,
+                });
+            }
+            await page.wait(1);
+        }
+        if (results.length === 0) {
+            results.push({ index: 0, status: 'info', user: 'System', message: 'No conversations processed' });
+        }
+        return results;
+    }
+});

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

@@ -0,0 +1,13 @@
+declare function resolveImagePath(imagePath: string): string;
+declare function extractTweetId(url: string): string;
+declare function buildReplyComposerUrl(url: string): string;
+declare function resolveImageExtension(url: string, contentType: string | null): string;
+declare function downloadRemoteImage(imageUrl: string): Promise<string>;
+export declare const __test__: {
+    buildReplyComposerUrl: typeof buildReplyComposerUrl;
+    downloadRemoteImage: typeof downloadRemoteImage;
+    extractTweetId: typeof extractTweetId;
+    resolveImageExtension: typeof resolveImageExtension;
+    resolveImagePath: typeof resolveImagePath;
+};
+export {};