@sovovs/bycli 1.8.0 → 2.0.0

package/clis/twitter/reply.test.js

@@ -1,237 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { JSDOM } from 'jsdom';
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { __test__ } from './reply.js';
-import { __test__ as utilsTest } from './utils.js';
-import { createPageMock } from '../test-utils.js';
-
-describe('twitter reply command', () => {
-    it('uses the dedicated reply composer for text-only replies too', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = createPageMock([
-            { ok: true },
-            { ok: true },
-            { ok: true, message: 'Reply posted successfully.' },
-        ]);
-        const result = await cmd.func(page, {
-            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
-            text: 'text-only reply',
-        });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
-        expect(page.wait).toHaveBeenCalledWith({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
-        expect(result).toEqual([
-            {
-                status: 'success',
-                message: 'Reply posted successfully.',
-                text: 'text-only reply',
-            },
-        ]);
-    });
-    it('uploads a local image through the dedicated reply composer when --image is provided', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-twitter-reply-'));
-        const imagePath = path.join(tempDir, 'qr.png');
-        fs.writeFileSync(imagePath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
-        const setFileInput = vi.fn().mockResolvedValue(undefined);
-        const page = createPageMock([
-            { ok: true, previewCount: 1 },
-            { ok: true },
-            { ok: true },
-            { ok: true, message: 'Reply posted successfully.' },
-        ], {
-            setFileInput,
-        });
-        const result = await cmd.func(page, {
-            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
-            text: 'reply with image',
-            image: imagePath,
-        });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
-        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
-        expect(page.wait).toHaveBeenNthCalledWith(2, { selector: 'input[type="file"][data-testid="fileInput"]', timeout: 20 });
-        expect(setFileInput).toHaveBeenCalledWith([imagePath], 'input[type="file"][data-testid="fileInput"]');
-        expect(result).toEqual([
-            {
-                status: 'success',
-                message: 'Reply posted successfully.',
-                text: 'reply with image',
-                image: imagePath,
-            },
-        ]);
-    });
-    it('downloads a remote image before uploading when --image-url is provided', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const fetchMock = vi.fn().mockResolvedValue({
-            ok: true,
-            headers: {
-                get: vi.fn().mockReturnValue('image/png'),
-            },
-            arrayBuffer: vi.fn().mockResolvedValue(Uint8Array.from([0x89, 0x50, 0x4e, 0x47]).buffer),
-        });
-        vi.stubGlobal('fetch', fetchMock);
-        const setFileInput = vi.fn().mockResolvedValue(undefined);
-        const page = createPageMock([
-            { ok: true, previewCount: 1 },
-            { ok: true },
-            { ok: true },
-            { ok: true, message: 'Reply posted successfully.' },
-        ], {
-            setFileInput,
-        });
-        const result = await cmd.func(page, {
-            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
-            text: 'reply with remote image',
-            'image-url': 'https://example.com/qr',
-        });
-        expect(fetchMock).toHaveBeenCalledWith('https://example.com/qr');
-        expect(setFileInput).toHaveBeenCalledTimes(1);
-        const uploadedPath = setFileInput.mock.calls[0][0][0];
-        // Tmp dir is created by utils.downloadRemoteImage with the
-        // 'bycli-twitter-' prefix; final extension comes from Content-Type.
-        expect(uploadedPath).toMatch(/bycli-twitter-.*\/image\.png$/);
-        // Per-call tmp dir is removed in the adapter's finally block, so the
-        // downloaded file no longer exists once the command returns.
-        expect(fs.existsSync(uploadedPath)).toBe(false);
-        expect(result).toEqual([
-            {
-                status: 'success',
-                message: 'Reply posted successfully.',
-                text: 'reply with remote image',
-                'image-url': 'https://example.com/qr',
-            },
-        ]);
-        vi.unstubAllGlobals();
-    });
-    it('falls back to the target tweet page when the dedicated composer route does not expose a textarea', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const wait = vi.fn()
-            .mockRejectedValueOnce(new Error('Selector not found: [data-testid="tweetTextarea_0"]'))
-            .mockResolvedValue(undefined);
-        const page = createPageMock([
-            { ok: true }, // click target tweet page Reply button
-            { ok: true }, // insert reply text
-            { ok: true }, // click composer Reply button
-            { ok: true, message: 'Reply posted successfully.' }, // submit completed
-        ], { wait });
-
-        const url = 'https://x.com/_kop6/status/2040254679301718161?s=20';
-        const result = await cmd.func(page, { url, text: 'fallback reply' });
-
-        expect(page.goto).toHaveBeenNthCalledWith(1, 'https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
-        expect(page.goto).toHaveBeenNthCalledWith(2, url, { waitUntil: 'load', settleMs: 2500 });
-        expect(page.evaluate.mock.calls[0][0]).toContain('[data-testid="reply"]');
-        expect(wait).toHaveBeenLastCalledWith({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
-        expect(result).toEqual([{ status: 'success', message: 'Reply posted successfully.', text: 'fallback reply' }]);
-    });
-    it('treats an X success toast as success after a Promise was collected error', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const evaluate = vi.fn()
-            .mockResolvedValueOnce({ ok: true }) // insert reply text
-            .mockResolvedValueOnce({ ok: true }) // click Reply
-            .mockRejectedValueOnce(new Error('{"code":-32000,"message":"Promise was collected"}'))
-            .mockResolvedValueOnce({
-                ok: true,
-                message: 'Reply posted successfully.',
-                url: 'https://x.com/me/status/123',
-            });
-        const page = createPageMock([], { evaluate });
-
-        const result = await cmd.func(page, {
-            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
-            text: 'toast recovery',
-        });
-
-        expect(page.wait).toHaveBeenCalledWith(2);
-        expect(result).toEqual([{
-            status: 'success',
-            message: 'Reply posted successfully.',
-            text: 'toast recovery',
-            url: 'https://x.com/me/status/123',
-        }]);
-    });
-    it('rejects using --image and --image-url together', async () => {
-        const cmd = getRegistry().get('twitter/reply');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = createPageMock([]);
-        await expect(cmd.func(page, {
-            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
-            text: 'nope',
-            image: '/tmp/a.png',
-            'image-url': 'https://example.com/a.png',
-        })).rejects.toThrow(CommandExecutionError);
-    });
-    it('rejects malformed tweet URLs before any browser interaction', () => {
-        // buildReplyComposerUrl runs parseTweetUrl synchronously; substring matches
-        // and off-domain hosts now throw ArgumentError instead of silently
-        // producing a wrong-host /compose/post URL.
-        expect(() => __test__.buildReplyComposerUrl('https://x.com/alice/home')).toThrow(ArgumentError);
-        expect(() => __test__.buildReplyComposerUrl('https://x.com.evil.com/alice/status/2040254679301718161')).toThrow(ArgumentError);
-        expect(() => __test__.buildReplyComposerUrl('not a url')).toThrow(ArgumentError);
-    });
-    it('builds the reply composer URL for both /<user>/status/<id> and /i/status/<id> shapes', () => {
-        expect(__test__.buildReplyComposerUrl('https://x.com/_kop6/status/2040254679301718161?s=20'))
-            .toBe('https://x.com/compose/post?in_reply_to=2040254679301718161');
-        expect(__test__.buildReplyComposerUrl('https://x.com/i/status/2040318731105313143'))
-            .toBe('https://x.com/compose/post?in_reply_to=2040318731105313143');
-    });
-});
-
-describe('twitter image helpers (utils.js)', () => {
-    it('rejects invalid image paths early', () => {
-        expect(() => utilsTest.resolveImagePath('/tmp/does-not-exist.png'))
-            .toThrow(ArgumentError);
-    });
-    it('prefers content-type when resolving remote image extensions', () => {
-        expect(utilsTest.resolveImageExtension('https://example.com/no-ext', 'image/webp')).toBe('.webp');
-        expect(utilsTest.resolveImageExtension('https://example.com/a.jpeg?x=1', null)).toBe('.jpeg');
-    });
-
-    it('classifies CDP NotAllowed file-input failures as recoverable', () => {
-        expect(utilsTest.isRecoverableFileInputError(new Error('NotAllowedError: Not allowed'))).toBe(true);
-        expect(utilsTest.isRecoverableFileInputError(new Error('ProtocolError: not-allowed'))).toBe(true);
-        expect(utilsTest.isRecoverableFileInputError(new Error('Permission denied'))).toBe(false);
-    });
-
-    it('fails closed when a composer image preview never appears', async () => {
-        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bycli-twitter-helper-'));
-        const imagePath = path.join(tempDir, 'missing-preview.png');
-        fs.writeFileSync(imagePath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
-        const page = createPageMock([{ ok: false, message: 'Image upload timed out (30s).' }], {
-            setFileInput: vi.fn().mockResolvedValue(undefined),
-        });
-
-        await expect(utilsTest.attachComposerImage(page, imagePath)).rejects.toThrow('Image upload timed out');
-        fs.rmSync(tempDir, { recursive: true, force: true });
-    });
-
-    it('does not treat an empty attachments container as uploaded media', async () => {
-        const runMediaReadyProbe = async (html) => {
-            const dom = new JSDOM(`<!doctype html><body>${html}</body>`, {
-                url: 'https://x.com/compose/post',
-                runScripts: 'outside-only',
-            });
-            dom.window.setTimeout = (callback) => {
-                callback();
-                return 0;
-            };
-            const page = {
-                evaluate: vi.fn(async (script) => dom.window.eval(script)),
-            };
-            return utilsTest.waitForComposerMediaReady(page, 1);
-        };
-
-        await expect(runMediaReadyProbe('<div data-testid="attachments"></div>'))
-            .resolves.toMatchObject({ ok: false });
-        await expect(runMediaReadyProbe('<div data-testid="attachments"><img src="blob:https://x.com/1"></div>'))
-            .resolves.toMatchObject({ ok: true, previewCount: 1 });
-    });
-});

package/clis/twitter/retweet.test.js

@@ -1,73 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './retweet.js';
-import { createPageMock } from '../test-utils.js';
-
-describe('twitter retweet command', () => {
-    it('clicks the retweet button then the confirm menu item and reports success', async () => {
-        const cmd = getRegistry().get('twitter/retweet');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = createPageMock([
-            { ok: true, message: 'Tweet successfully retweeted.' },
-        ]);
-        const result = await cmd.func(page, {
-            url: 'https://x.com/alice/status/2040254679301718161',
-        });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/alice/status/2040254679301718161');
-        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="primaryColumn"]' });
-        expect(page.wait).toHaveBeenNthCalledWith(2, 2);
-        const script = page.evaluate.mock.calls[0][0];
-        // Two-step UI flow must be present:
-        //   1) click the retweet button
-        //   2) wait for and click the confirm menu item (data-testid="retweetConfirm")
-        expect(script).toContain('retweetBtn.click()');
-        expect(script).toContain("document.querySelector('[data-testid=\"retweetConfirm\"]')");
-        expect(script).toContain('confirmBtn.click()');
-        // Article scoping comes from the shared helper (buildTwitterArticleScopeSource):
-        // emits __twHasLinkToTarget + __twGetStatusIdFromHref + the anchored
-        // tweet-path regex. JSDOM-level coverage lives in shared.test.js.
-        expect(script).toContain('__twHasLinkToTarget');
-        expect(script).toContain('__twGetStatusIdFromHref');
-        expect(script).toContain("document.querySelectorAll('article')");
-        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"retweet\"]')");
-        // Idempotency probe: when already retweeted ([data-testid="unretweet"] present),
-        // the script returns ok:true with an "already retweeted" message.
-        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"unretweet\"]')");
-        expect(result).toEqual([
-            { status: 'success', message: 'Tweet successfully retweeted.' },
-        ]);
-    });
-
-    it('returns a failed row when the confirm menu item never appears', async () => {
-        const cmd = getRegistry().get('twitter/retweet');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = createPageMock([
-            { ok: false, message: 'Retweet menu opened but the confirm option did not appear.' },
-        ]);
-        const result = await cmd.func(page, {
-            url: 'https://x.com/alice/status/2040254679301718161',
-        });
-        expect(result).toEqual([
-            { status: 'failed', message: 'Retweet menu opened but the confirm option did not appear.' },
-        ]);
-        expect(page.wait).toHaveBeenCalledTimes(1);
-    });
-
-    it('throws CommandExecutionError when no page is provided', async () => {
-        const cmd = getRegistry().get('twitter/retweet');
-        await expect(cmd.func(undefined, {
-            url: 'https://x.com/alice/status/2040254679301718161',
-        })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('rejects invalid tweet URLs before navigation', async () => {
-        const cmd = getRegistry().get('twitter/retweet');
-        const page = createPageMock([]);
-        await expect(cmd.func(page, {
-            url: 'https://evil.com/?next=https://x.com/alice/status/2040254679301718161',
-        })).rejects.toThrow(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-});

package/clis/twitter/search.test.js

@@ -1,349 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { __test__ } from './search.js';
-
-const { buildSearchQuery, resolveSearchFParam, resolveSearchProduct, buildSearchTimelineRequest, parseSearchTimeline, HAS_CHOICES, EXCLUDE_CHOICES, PRODUCT_CHOICES, EXCLUDE_TO_OPERATOR, PRODUCT_TO_F_PARAM, FROM_USER_PATTERN } = __test__;
-describe('twitter search command', () => {
-    function makeSearchPage(data) {
-        return {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn()
-                .mockResolvedValueOnce(null) // resolveTwitterQueryId fallback
-                .mockResolvedValueOnce(data),
-        };
-    }
-
-    it('fetches SearchTimeline directly instead of relying on SPA navigation', async () => {
-        const command = getRegistry().get('twitter/search');
-        expect(command?.func).toBeTypeOf('function');
-        const page = makeSearchPage({
-            data: {
-                search_by_raw_query: {
-                    search_timeline: {
-                        timeline: {
-                            instructions: [
-                                {
-                                    type: 'TimelineAddEntries',
-                                    entries: [
-                                        {
-                                            entryId: 'tweet-1',
-                                            content: {
-                                                itemContent: {
-                                                    tweet_results: {
-                                                        result: {
-                                                            rest_id: '1',
-                                                            legacy: {
-                                                                full_text: 'hello world',
-                                                                favorite_count: 7,
-                                                                created_at: 'Thu Mar 26 10:30:00 +0000 2026',
-                                                            },
-                                                            core: {
-                                                                user_results: {
-                                                                    result: {
-                                                                        core: {
-                                                                            screen_name: 'alice',
-                                                                        },
-                                                                        legacy: {
-                                                                            description: 'Search author bio',
-                                                                        },
-                                                                    },
-                                                                },
-                                                            },
-                                                            views: {
-                                                                count: '12',
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    },
-                },
-            },
-        });
-        const result = await command.func(page, { query: 'from:alice', filter: 'top', limit: 5 });
-        expect(result).toEqual([
-            {
-                id: '1',
-                author: 'alice',
-                bio: 'Search author bio',
-                text: 'hello world',
-                created_at: 'Thu Mar 26 10:30:00 +0000 2026',
-                likes: 7,
-                views: '12',
-                url: 'https://x.com/i/status/1',
-                has_media: false,
-                media_urls: [],
-                card: null,
-                quoted_tweet: null,
-            },
-        ]);
-        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/home', { waitUntil: 'load', settleMs: 1000 });
-        const searchFetch = page.evaluate.mock.calls[1][0];
-        expect(searchFetch).toContain('/SearchTimeline');
-        expect(searchFetch).toContain("method: 'POST'");
-        expect(searchFetch).toContain('\\"rawQuery\\":\\"from:alice\\"');
-    });
-
-    it('uses the requested GraphQL product', async () => {
-        const command = getRegistry().get('twitter/search');
-        const page = makeSearchPage({ data: { search_by_raw_query: { search_timeline: { timeline: { instructions: [] } } } } });
-        await command.func(page, { query: 'cats', product: 'videos', limit: 5 });
-        expect(page.evaluate.mock.calls[1][0]).toContain('\\"product\\":\\"Videos\\"');
-    });
-
-    it('paginates past the old five-page cap until the requested limit is reached', async () => {
-        const command = getRegistry().get('twitter/search');
-        let pageIndex = 0;
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockImplementation(async () => {
-                if (pageIndex === 0) {
-                    pageIndex += 1;
-                    return null;
-                }
-                const id = String(pageIndex);
-                pageIndex += 1;
-                return {
-                    data: {
-                        search_by_raw_query: {
-                            search_timeline: {
-                                timeline: {
-                                    instructions: [
-                                        {
-                                            entries: [
-                                                {
-                                                    content: {
-                                                        itemContent: {
-                                                            tweet_results: {
-                                                                result: {
-                                                                    rest_id: id,
-                                                                    legacy: { full_text: `tweet ${id}`, created_at: 'now' },
-                                                                    core: { user_results: { result: { core: { screen_name: 'alice' } } } },
-                                                                },
-                                                            },
-                                                        },
-                                                    },
-                                                },
-                                                {
-                                                    content: {
-                                                        entryType: 'TimelineTimelineCursor',
-                                                        cursorType: 'Bottom',
-                                                        value: `cursor-${id}`,
-                                                    },
-                                                },
-                                            ],
-                                        },
-                                    ],
-                                },
-                            },
-                        },
-                    },
-                };
-            }),
-        };
-        const result = await command.func(page, { query: 'bycli', limit: 7 });
-        expect(result).toHaveLength(7);
-        expect(result.map((row) => row.id)).toEqual(['1', '2', '3', '4', '5', '6', '7']);
-        expect(page.evaluate).toHaveBeenCalledTimes(8);
-    });
-});
-
-describe('twitter search filter helpers', () => {
-    describe('buildSearchQuery', () => {
-        it('returns the trimmed raw query when no filters are set', () => {
-            expect(buildSearchQuery('  hello world  ', {})).toBe('hello world');
-        });
-        it('appends from: with leading @ stripped', () => {
-            expect(buildSearchQuery('hello', { from: '@alice' })).toBe('hello from:alice');
-        });
-        it('preserves from: when caller passes a bare username', () => {
-            expect(buildSearchQuery('hello', { from: 'alice' })).toBe('hello from:alice');
-        });
-        it('strips multiple leading @ characters from --from', () => {
-            expect(buildSearchQuery('hi', { from: '@@bob' })).toBe('hi from:bob');
-        });
-        it('drops --from when it is whitespace-only', () => {
-            expect(buildSearchQuery('hi', { from: '   ' })).toBe('hi');
-        });
-        it('rejects invalid --from usernames instead of injecting raw operators', () => {
-            expect(() => buildSearchQuery('hi', { from: 'alice filter:links' })).toThrow(/Invalid --from/);
-            expect(() => buildSearchQuery('hi', { from: 'alice/bob' })).toThrow(/Invalid --from/);
-            expect(() => buildSearchQuery('hi', { from: '@' + 'a'.repeat(16) })).toThrow(/Invalid --from/);
-        });
-        it('appends filter:<has> for --has', () => {
-            expect(buildSearchQuery('q', { has: 'images' })).toBe('q filter:images');
-        });
-        it('maps --exclude retweets to -filter:nativeretweets', () => {
-            expect(buildSearchQuery('q', { exclude: 'retweets' })).toBe('q -filter:nativeretweets');
-        });
-        it('maps --exclude replies/media/links to their -filter operators', () => {
-            expect(buildSearchQuery('q', { exclude: 'replies' })).toBe('q -filter:replies');
-            expect(buildSearchQuery('q', { exclude: 'media' })).toBe('q -filter:media');
-            expect(buildSearchQuery('q', { exclude: 'links' })).toBe('q -filter:links');
-        });
-        it('silently ignores unknown --exclude values', () => {
-            // choices: ['replies','retweets','media','links'] — unknowns shouldn't appear
-            // in real CLI use because the validator rejects them, but the helper still
-            // guards via the EXCLUDE_TO_OPERATOR map lookup.
-            expect(buildSearchQuery('q', { exclude: 'bogus' })).toBe('q');
-        });
-        it('composes multiple filter clauses in stable order: query → from → has → exclude', () => {
-            expect(buildSearchQuery('hot take', {
-                from: '@alice',
-                has: 'media',
-                exclude: 'retweets',
-            })).toBe('hot take from:alice filter:media -filter:nativeretweets');
-        });
-        it('allows an empty raw query when filters are present', () => {
-            expect(buildSearchQuery('', { from: 'alice' })).toBe('from:alice');
-        });
-        it('returns empty string when nothing useful is supplied', () => {
-            expect(buildSearchQuery('', {})).toBe('');
-            expect(buildSearchQuery('   ', {})).toBe('');
-        });
-        it('coerces nullish raw query into empty string', () => {
-            expect(buildSearchQuery(null, { from: 'alice' })).toBe('from:alice');
-            expect(buildSearchQuery(undefined, { from: 'alice' })).toBe('from:alice');
-        });
-    });
-
-    describe('resolveSearchFParam', () => {
-        it('defaults to top when neither product nor filter is set', () => {
-            expect(resolveSearchFParam({})).toBe('top');
-        });
-        it('returns top when filter=top', () => {
-            expect(resolveSearchFParam({ filter: 'top' })).toBe('top');
-        });
-        it('returns live when filter=live', () => {
-            expect(resolveSearchFParam({ filter: 'live' })).toBe('live');
-        });
-        it('maps --product photos to image (Twitter URL singular form)', () => {
-            expect(resolveSearchFParam({ product: 'photos' })).toBe('image');
-        });
-        it('maps --product videos to video (Twitter URL singular form)', () => {
-            expect(resolveSearchFParam({ product: 'videos' })).toBe('video');
-        });
-        it('maps --product top|live straight through', () => {
-            expect(resolveSearchFParam({ product: 'top' })).toBe('top');
-            expect(resolveSearchFParam({ product: 'live' })).toBe('live');
-        });
-        it('lets --product win when both --product and --filter are set', () => {
-            expect(resolveSearchFParam({ product: 'photos', filter: 'live' })).toBe('image');
-            expect(resolveSearchFParam({ product: 'top', filter: 'live' })).toBe('top');
-        });
-        it('falls back to filter when --product is unknown', () => {
-            // unknowns are blocked at the CLI validator layer; this is just defence
-            expect(resolveSearchFParam({ product: 'bogus', filter: 'live' })).toBe('live');
-            expect(resolveSearchFParam({ product: 'bogus' })).toBe('top');
-        });
-    });
-
-    describe('choice surface', () => {
-        it('exposes the documented HAS_CHOICES set', () => {
-            expect(HAS_CHOICES).toEqual(['media', 'images', 'videos', 'links', 'replies']);
-        });
-        it('exposes the documented EXCLUDE_CHOICES set', () => {
-            expect(EXCLUDE_CHOICES).toEqual(['replies', 'retweets', 'media', 'links']);
-        });
-        it('exposes the documented PRODUCT_CHOICES set', () => {
-            expect(PRODUCT_CHOICES).toEqual(['top', 'live', 'photos', 'videos']);
-        });
-        it('keeps PRODUCT_TO_F_PARAM domain a strict subset of PRODUCT_CHOICES', () => {
-            for (const choice of PRODUCT_CHOICES) {
-                expect(PRODUCT_TO_F_PARAM[choice]).toBeTypeOf('string');
-            }
-        });
-        it('keeps EXCLUDE_TO_OPERATOR domain a strict subset of EXCLUDE_CHOICES', () => {
-            for (const choice of EXCLUDE_CHOICES) {
-                expect(EXCLUDE_TO_OPERATOR[choice]).toMatch(/^-filter:/);
-            }
-        });
-        it('keeps FROM_USER_PATTERN aligned with X handle syntax', () => {
-            expect(FROM_USER_PATTERN.test('alice_123')).toBe(true);
-            expect(FROM_USER_PATTERN.test('a'.repeat(15))).toBe(true);
-            expect(FROM_USER_PATTERN.test('a'.repeat(16))).toBe(false);
-            expect(FROM_USER_PATTERN.test('alice/bob')).toBe(false);
-        });
-    });
-});
-
-describe('twitter search end-to-end with new filters', () => {
-    it('encodes the composed query and product=live into the GraphQL request', async () => {
-        const command = getRegistry().get('twitter/search');
-        const evaluate = vi.fn()
-            .mockResolvedValueOnce(null)
-            .mockResolvedValueOnce({ data: { search_by_raw_query: { search_timeline: { timeline: { instructions: [] } } } } });
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate,
-        };
-        await command.func(page, {
-            query: 'breaking news',
-            from: '@alice',
-            has: 'images',
-            exclude: 'retweets',
-            product: 'live',
-            limit: 5,
-        });
-        const searchFetch = evaluate.mock.calls[1][0];
-        expect(searchFetch).toContain('\\"product\\":\\"Latest\\"');
-        expect(searchFetch).toContain('\\"rawQuery\\":\\"breaking news from:alice filter:images -filter:nativeretweets\\"');
-    });
-    it('throws ArgumentError when query and all filters are empty', async () => {
-        const command = getRegistry().get('twitter/search');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn(),
-        };
-        await expect(command.func(page, { query: '   ', limit: 5 }))
-            .rejects
-            .toThrow(/empty/i);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-    it('throws ArgumentError for invalid --from before navigation', async () => {
-        const command = getRegistry().get('twitter/search');
-        const page = {
-            goto: vi.fn(),
-            evaluate: vi.fn(),
-        };
-        await expect(command.func(page, { query: 'hi', from: 'alice filter:links', limit: 5 }))
-            .rejects
-            .toThrow(/Invalid --from/);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-    it('throws ArgumentError for invalid --limit before navigation', async () => {
-        const command = getRegistry().get('twitter/search');
-        const page = {
-            goto: vi.fn(),
-            evaluate: vi.fn(),
-        };
-        await expect(command.func(page, { query: 'hi', limit: 0 }))
-            .rejects
-            .toThrow(/--limit/);
-        expect(page.goto).not.toHaveBeenCalled();
-    });
-    it('runs with only filters set (empty <query>)', async () => {
-        const command = getRegistry().get('twitter/search');
-        const evaluate = vi.fn()
-            .mockResolvedValueOnce(null)
-            .mockResolvedValueOnce({ data: { search_by_raw_query: { search_timeline: { timeline: { instructions: [] } } } } });
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
-            goto: vi.fn().mockResolvedValue(undefined),
-            evaluate,
-        };
-        const result = await command.func(page, { query: '', from: 'alice', limit: 5 });
-        expect(result).toEqual([]);
-        const searchFetch = evaluate.mock.calls[1][0];
-        expect(searchFetch).toContain('\\"rawQuery\\":\\"from:alice\\"');
-    });
-});