@jackwener/opencli 1.7.8 → 1.7.10

package/clis/twitter/following.test.js

@@ -0,0 +1,277 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { __test__ } from './following.js';
+
+describe('twitter following helpers', () => {
+    it('falls back when queryId contains unsafe characters', () => {
+        expect(__test__.sanitizeQueryId('safe_Query-123', 'fallback')).toBe('safe_Query-123');
+        expect(__test__.sanitizeQueryId('bad"id', 'fallback')).toBe('fallback');
+        expect(__test__.sanitizeQueryId('bad/id', 'fallback')).toBe('fallback');
+        expect(__test__.sanitizeQueryId(null, 'fallback')).toBe('fallback');
+    });
+
+    it('builds following url with cursor', () => {
+        const url = __test__.buildFollowingUrl('query123', '42', 20, 'cursor-1');
+        expect(url).toContain('/i/api/graphql/query123/Following');
+        expect(decodeURIComponent(url)).toContain('"userId":"42"');
+        expect(decodeURIComponent(url)).toContain('"count":20');
+        expect(decodeURIComponent(url)).toContain('"cursor":"cursor-1"');
+    });
+
+    it('builds following url without cursor', () => {
+        const url = __test__.buildFollowingUrl('query123', '42', 20);
+        expect(url).toContain('/i/api/graphql/query123/Following');
+        expect(decodeURIComponent(url)).not.toContain('"cursor"');
+    });
+
+    it('extracts user from result', () => {
+        const user = __test__.extractUser({
+            __typename: 'User',
+            core: { screen_name: 'alice', name: 'Alice' },
+            legacy: { description: 'bio text', followers_count: 100 },
+        });
+        expect(user).toMatchObject({
+            screen_name: 'alice',
+            name: 'Alice',
+            bio: 'bio text',
+            followers: 100,
+        });
+    });
+
+    it('returns null for non-User typename', () => {
+        expect(__test__.extractUser({ __typename: 'Tweet' })).toBeNull();
+        expect(__test__.extractUser(null)).toBeNull();
+        expect(__test__.extractUser(undefined)).toBeNull();
+    });
+
+    it('falls back to legacy screen_name if core is missing', () => {
+        const user = __test__.extractUser({
+            __typename: 'User',
+            legacy: { screen_name: 'bob', name: 'Bob', description: '', followers_count: 0 },
+        });
+        expect(user?.screen_name).toBe('bob');
+    });
+
+    it('parses following timeline with users and cursor', () => {
+        const payload = {
+            data: {
+                user: {
+                    result: {
+                        timeline_v2: {
+                            timeline: {
+                                instructions: [{
+                                    entries: [
+                                        {
+                                            entryId: 'user-1',
+                                            content: {
+                                                itemContent: {
+                                                    user_results: {
+                                                        result: {
+                                                            __typename: 'User',
+                                                            core: { screen_name: 'bob', name: 'Bob' },
+                                                            legacy: { description: 'hello', followers_count: 50 },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                        {
+                                            entryId: 'user-2',
+                                            content: {
+                                                itemContent: {
+                                                    user_results: {
+                                                        result: {
+                                                            __typename: 'User',
+                                                            core: { screen_name: 'carol', name: 'Carol' },
+                                                            legacy: { description: 'world', followers_count: 200 },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                        {
+                                            entryId: 'cursor-bottom-1',
+                                            content: {
+                                                entryType: 'TimelineTimelineCursor',
+                                                cursorType: 'Bottom',
+                                                value: 'next-cursor',
+                                            },
+                                        },
+                                    ],
+                                }],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = __test__.parseFollowing(payload);
+        expect(result.users).toHaveLength(2);
+        expect(result.users[0]).toMatchObject({ screen_name: 'bob', name: 'Bob', followers: 50 });
+        expect(result.users[1]).toMatchObject({ screen_name: 'carol', name: 'Carol', followers: 200 });
+        expect(result.nextCursor).toBe('next-cursor');
+    });
+
+    it('handles cursor-bottom entryId pattern', () => {
+        const payload = {
+            data: {
+                user: {
+                    result: {
+                        timeline: {
+                            timeline: {
+                                instructions: [{
+                                    entries: [
+                                        {
+                                            entryId: 'cursor-bottom-0',
+                                            content: {
+                                                itemContent: { value: 'cursor-val' },
+                                            },
+                                        },
+                                    ],
+                                }],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = __test__.parseFollowing(payload);
+        expect(result.nextCursor).toBe('cursor-val');
+        expect(result.users).toHaveLength(0);
+    });
+
+    it('returns empty users and null cursor for missing instructions', () => {
+        const result = __test__.parseFollowing({ data: { user: { result: {} } } });
+        expect(result.users).toHaveLength(0);
+        expect(result.nextCursor).toBeNull();
+    });
+
+    it('returns empty for completely empty payload', () => {
+        const result = __test__.parseFollowing({});
+        expect(result.users).toHaveLength(0);
+        expect(result.nextCursor).toBeNull();
+    });
+
+    it('normalizes screen names for CLI and profile-link inputs', () => {
+        expect(__test__.normalizeScreenName('@elonmusk')).toBe('elonmusk');
+        expect(__test__.normalizeScreenName('/elonmusk')).toBe('elonmusk');
+        expect(__test__.normalizeScreenName('  @@alice  ')).toBe('alice');
+    });
+});
+
+function followingPayload(users, cursor) {
+    return {
+        data: {
+            user: {
+                result: {
+                    timeline_v2: {
+                        timeline: {
+                            instructions: [{
+                                entries: [
+                                    ...users.map((name) => ({
+                                        entryId: `user-${name}`,
+                                        content: {
+                                            itemContent: {
+                                                user_results: {
+                                                    result: {
+                                                        __typename: 'User',
+                                                        core: { screen_name: name, name: name.toUpperCase() },
+                                                        legacy: { description: `${name} bio`, followers_count: 10 },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    })),
+                                    ...(cursor ? [{
+                                        entryId: `cursor-bottom-${cursor}`,
+                                        content: {
+                                            entryType: 'TimelineTimelineCursor',
+                                            cursorType: 'Bottom',
+                                            value: cursor,
+                                        },
+                                    }] : []),
+                                ],
+                            }],
+                        },
+                    },
+                },
+            },
+        },
+    };
+}
+
+function createFollowingPage(followingResponses, { ct0 = 'token', userLookup = { userId: '42' } } = {}) {
+    const page = {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn(async (script) => {
+            if (script.includes('document.cookie')) return ct0;
+            if (script.includes('operationName')) return null;
+            if (script.includes('/UserByScreenName')) return userLookup;
+            if (script.includes('/Following')) return followingResponses.shift() || followingPayload([], null);
+            if (script.includes('AppTabBar_Profile_Link')) return '/viewer';
+            throw new Error(`Unexpected evaluate script: ${script.slice(0, 80)}`);
+        }),
+    };
+    return page;
+}
+
+describe('twitter following command', () => {
+    it('paginates with cursor, deduplicates users, strips @, and respects limit', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([
+            followingPayload(['alice', 'bob'], 'cursor-1'),
+            followingPayload(['bob', 'carol', 'dave'], null),
+        ]);
+
+        const rows = await command.func(page, { user: '@elonmusk', limit: 3 });
+
+        expect(rows.map((row) => row.screen_name)).toEqual(['alice', 'bob', 'carol']);
+        const userLookupScript = page.evaluate.mock.calls.find(([script]) => script.includes('/UserByScreenName'))?.[0] || '';
+        expect(decodeURIComponent(userLookupScript)).toContain('"screen_name":"elonmusk"');
+        expect(decodeURIComponent(userLookupScript)).not.toContain('"screen_name":"@elonmusk"');
+        const followingCalls = page.evaluate.mock.calls.filter(([script]) => script.includes('/Following'));
+        expect(followingCalls).toHaveLength(2);
+        expect(decodeURIComponent(followingCalls[1][0])).toContain('"cursor":"cursor-1"');
+    });
+
+    it('rejects invalid limits before navigating', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([]);
+
+        await expect(command.func(page, { user: 'elonmusk', limit: 0 })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('maps first-page auth failures to AuthRequiredError', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([{ error: 401 }]);
+
+        await expect(command.func(page, { user: 'elonmusk', limit: 10 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('does not silently return partial rows when a later page fails', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([
+            followingPayload(['alice'], 'cursor-1'),
+            { error: 429 },
+        ]);
+
+        await expect(command.func(page, { user: 'elonmusk', limit: 10 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('maps user lookup auth failures to AuthRequiredError', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([], { userLookup: { error: 403 } });
+
+        await expect(command.func(page, { user: 'elonmusk', limit: 10 })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('fails fast when the following timeline is empty', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([followingPayload([], null)]);
+
+        await expect(command.func(page, { user: 'elonmusk', limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+});

package/clis/twitter/post.js

@@ -2,10 +2,18 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CommandExecutionError } from '@jackwener/opencli/errors';
+
 const MAX_IMAGES = 4;
 const UPLOAD_POLL_MS = 500;
 const UPLOAD_TIMEOUT_MS = 30_000;
+const COMPOSER_POLL_MS = 250;
+const COMPOSER_TIMEOUT_MS = 10_000;
+const SUBMIT_POLL_MS = 500;
+const SUBMIT_TIMEOUT_MS = 15_000;
+const COMPOSE_URL = 'https://x.com/compose/post';
+const FILE_INPUT_SELECTOR = 'input[type="file"][data-testid="fileInput"]';
 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) {
@@ -24,6 +32,156 @@ function validateImagePaths(raw) {
         return absPath;
     });
 }
+
+function isUnsupportedInsertTextError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const lower = msg.toLowerCase();
+    return lower.includes('unknown action') || lower.includes('not supported') || lower.includes('inserttext returned no inserted flag');
+}
+
+async function focusComposer(page) {
+    return page.evaluate(`(() => {
+        const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+        const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]'));
+        const box = boxes.find(visible) || boxes[0];
+        if (!box) return { ok: false, message: 'Could not find the tweet composer text area. Are you logged in?' };
+        box.focus();
+        return { ok: true };
+    })()`);
+}
+
+async function verifyComposerText(page, text) {
+    const iterations = Math.ceil(COMPOSER_TIMEOUT_MS / COMPOSER_POLL_MS);
+    return page.evaluate(`(async () => {
+        const expected = ${JSON.stringify(text)};
+        const normalize = s => String(s || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
+        const normalizedExpected = normalize(expected);
+        for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+            const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+            const actual = box ? (box.innerText || box.textContent || '') : '';
+            if (box && normalize(actual).includes(normalizedExpected)) return { ok: true };
+            await new Promise(r => setTimeout(r, ${JSON.stringify(COMPOSER_POLL_MS)}));
+        }
+        const box = document.querySelector('[data-testid="tweetTextarea_0"]');
+        return {
+            ok: false,
+            message: 'Could not verify tweet text in the composer after typing.',
+            actualText: box ? (box.innerText || box.textContent || '') : ''
+        };
+    })()`);
+}
+
+async function insertComposerText(page, text) {
+    const focusResult = await focusComposer(page);
+    if (!focusResult?.ok) return focusResult;
+
+    const nativeInserters = [
+        page.nativeType?.bind(page),
+        page.insertText?.bind(page),
+    ].filter(Boolean);
+
+    for (const insert of nativeInserters) {
+        try {
+            // Native CDP Input.insertText updates Twitter/X's Draft.js editor much more
+            // reliably than synthetic paste/input events. Prefer the Page CDP helper
+            // when available because older Browser Bridge insert-text can report
+            // inserted while the editor state does not change after media upload.
+            await insert(text);
+            const verified = await verifyComposerText(page, text);
+            if (verified?.ok) return verified;
+        }
+        catch (err) {
+            if (!isUnsupportedInsertTextError(err)) throw err;
+            // Older Browser Bridge versions do not expose this insertion path; try the next one.
+        }
+    }
+
+    return page.evaluate(`(async () => {
+        try {
+            const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+            const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]'));
+            const box = boxes.find(visible) || boxes[0];
+            if (!box) return { ok: false, message: 'Could not find the tweet composer text area. Are you logged in?' };
+            const textToInsert = ${JSON.stringify(text)};
+            const normalize = s => String(s || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
+            box.focus();
+            if (!document.execCommand('insertText', false, textToInsert)) {
+                const dt = new DataTransfer();
+                dt.setData('text/plain', textToInsert);
+                box.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true }));
+            }
+            await new Promise(r => setTimeout(r, 500));
+            const actual = box.innerText || box.textContent || '';
+            if (normalize(actual).includes(normalize(textToInsert))) return { ok: true };
+            return { ok: false, message: 'Could not verify tweet text in the composer after typing.', actualText: actual };
+        } catch (e) { return { ok: false, message: String(e) }; }
+    })()`);
+}
+
+async function waitForImageUpload(page, expectedCount) {
+    const iterations = Math.ceil(UPLOAD_TIMEOUT_MS / UPLOAD_POLL_MS);
+    return page.evaluate(`(async () => {
+        const expected = ${JSON.stringify(expectedCount)};
+        const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+        for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+            await new Promise(r => setTimeout(r, ${JSON.stringify(UPLOAD_POLL_MS)}));
+            const attachments = document.querySelector('[data-testid="attachments"]');
+            const previewCount = Math.max(
+                attachments ? attachments.querySelectorAll('[role="group"], img, video').length : 0,
+                document.querySelectorAll('[data-testid="tweetPhoto"], img[src^="blob:"], video[src^="blob:"]').length,
+                Array.from(document.querySelectorAll('button,[role="button"]')).filter((el) =>
+                    /remove media|remove image|remove/i.test((el.getAttribute('aria-label') || '') + ' ' + (el.textContent || ''))
+                ).length
+            );
+            const button = Array.from(document.querySelectorAll('[data-testid="tweetButtonInline"], [data-testid="tweetButton"]'))
+                .find((el) => visible(el));
+            const buttonReady = !!button && !button.disabled && button.getAttribute('aria-disabled') !== 'true';
+            if (previewCount >= expected && buttonReady) return { ok: true, previewCount };
+        }
+        return { ok: false, message: 'Image upload timed out (${UPLOAD_TIMEOUT_MS / 1000}s).' };
+    })()`);
+}
+
+async function submitTweet(page, text) {
+    const clickResult = await page.evaluate(`(async () => {
+        try {
+            const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+            const buttons = Array.from(document.querySelectorAll('[data-testid="tweetButtonInline"], [data-testid="tweetButton"]'));
+            const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+            if (!btn) return { ok: false, message: 'Tweet button is disabled or not found.' };
+            btn.click();
+            return { ok: true };
+        } catch (e) { return { ok: false, message: String(e) }; }
+    })()`);
+    if (!clickResult?.ok) return clickResult;
+
+    const iterations = Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS);
+    return page.evaluate(`(async () => {
+        const expected = ${JSON.stringify(text)};
+        const normalize = s => String(s || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
+        const expectedText = normalize(expected);
+        const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+        for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+            await new Promise(r => setTimeout(r, ${JSON.stringify(SUBMIT_POLL_MS)}));
+            const toasts = Array.from(document.querySelectorAll('[role="alert"], [data-testid="toast"]'))
+                .filter((el) => visible(el));
+            const successToast = toasts.find((el) => /sent|posted|your post was sent|your tweet was sent/i.test(el.textContent || ''));
+            if (successToast) return { ok: true, message: 'Tweet posted successfully.' };
+            const alert = toasts.find((el) => /failed|error|try again|not sent|could not/i.test(el.textContent || ''));
+            if (alert) return { ok: false, message: (alert.textContent || 'Tweet failed to post.').trim() };
+
+            const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]')).filter(visible);
+            const composerStillHasText = boxes.some((box) => normalize(box.innerText || box.textContent || '').includes(expectedText));
+            const hasMedia = !!document.querySelector('[data-testid="attachments"], [data-testid="tweetPhoto"]')
+                || document.querySelectorAll('img[src^="blob:"], video[src^="blob:"]').length > 0;
+            if (!composerStillHasText && !hasMedia) {
+                return { ok: true, message: 'Tweet posted successfully.' };
+            }
+        }
+        return { ok: false, message: 'Tweet submission did not complete before timeout.' };
+    })()`);
+}
+
 cli({
     site: 'twitter',
     name: 'post',
@@ -39,60 +197,39 @@ cli({
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter post');
-        // Validate images upfront before any browser interaction
+
+        // 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
+        const text = String(kwargs.text ?? '');
+
+        // The current X standalone composer is /compose/post. It keeps a single,
+        // visible composer and is the same route used by the reply command.
+        await page.goto(COMPOSE_URL, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+
+        // Attach media before inserting text. Uploading media after Draft.js has
+        // text can re-render/reset the editor, causing image-only posts.
         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 }];
+            await page.wait({ selector: FILE_INPUT_SELECTOR, timeout: 20 });
+            await page.setFileInput(absPaths, FILE_INPUT_SELECTOR);
+            const uploadState = await waitForImageUpload(page, absPaths.length);
+            if (!uploadState?.ok) {
+                return [{ status: 'failed', message: uploadState?.message ?? `Image upload timed out (${UPLOAD_TIMEOUT_MS / 1000}s).`, text }];
             }
         }
-        // 4. Click the post button
+
+        // Insert and verify the text after media upload so text + images are in
+        // the final Draft.js composer state immediately before clicking Post.
+        const typeResult = await insertComposerText(page, text);
+        if (!typeResult?.ok) {
+            return [{ status: 'failed', message: typeResult?.message ?? 'Could not type tweet text.', text }];
+        }
+
         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 }];
+        const result = await submitTweet(page, text);
+        return [{ status: result?.ok ? 'success' : 'failed', message: result?.message ?? 'Tweet failed to post.', text }];
     }
 });