@sovovs/bycli 1.8.0 → 2.0.0

package/clis/twitter/bookmarks.test.js

@@ -1,205 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { __test__ } from './bookmarks.js';
-
-const { parseBookmarks, extractBookmarkTweet } = __test__;
-
-describe('twitter bookmarks parser', () => {
-    it('extracts a baseline tweet with no media (has_media false, media_urls empty)', () => {
-        const tweet = extractBookmarkTweet({
-            rest_id: '1',
-            legacy: {
-                full_text: 'plain bookmark',
-                favorite_count: 5,
-                retweet_count: 1,
-                bookmark_count: 2,
-                created_at: 'Wed Apr 16 10:00:00 +0000 2026',
-            },
-            core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
-        }, new Set());
-        expect(tweet).toEqual({
-            id: '1',
-            author: 'alice',
-            name: 'Alice',
-            text: 'plain bookmark',
-            likes: 5,
-            retweets: 1,
-            bookmarks: 2,
-            created_at: 'Wed Apr 16 10:00:00 +0000 2026',
-            url: 'https://x.com/alice/status/1',
-            has_media: false,
-            media_urls: [],
-        });
-    });
-
-    it('includes photo media URLs from extended_entities', () => {
-        const tweet = extractBookmarkTweet({
-            rest_id: '101',
-            legacy: {
-                full_text: 'pic bookmark',
-                extended_entities: {
-                    media: [
-                        { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/abc.jpg' },
-                        { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/def.jpg' },
-                    ],
-                },
-            },
-            core: { user_results: { result: { legacy: { screen_name: 'bob' } } } },
-        }, new Set());
-        expect(tweet?.has_media).toBe(true);
-        expect(tweet?.media_urls).toEqual([
-            'https://pbs.twimg.com/media/abc.jpg',
-            'https://pbs.twimg.com/media/def.jpg',
-        ]);
-    });
-
-    it('extracts mp4 variant URL for video media', () => {
-        const tweet = extractBookmarkTweet({
-            rest_id: '102',
-            legacy: {
-                full_text: 'video bookmark',
-                extended_entities: {
-                    media: [{
-                        type: 'video',
-                        media_url_https: 'https://pbs.twimg.com/amplify_video_thumb/thumb.jpg',
-                        video_info: {
-                            variants: [
-                                { content_type: 'application/x-mpegURL', url: 'https://video.twimg.com/playlist.m3u8' },
-                                { content_type: 'video/mp4', bitrate: 832000, url: 'https://video.twimg.com/low.mp4' },
-                                { content_type: 'video/mp4', bitrate: 2176000, url: 'https://video.twimg.com/high.mp4' },
-                            ],
-                        },
-                    }],
-                },
-            },
-            core: { user_results: { result: { legacy: { screen_name: 'carol' } } } },
-        }, new Set());
-        expect(tweet?.has_media).toBe(true);
-        expect(tweet?.media_urls?.[0]).toMatch(/\.mp4$/);
-    });
-
-    it('falls back to entities.media when extended_entities is absent', () => {
-        const tweet = extractBookmarkTweet({
-            rest_id: '103',
-            legacy: {
-                full_text: 'entities-only media',
-                entities: {
-                    media: [{ type: 'photo', media_url_https: 'https://pbs.twimg.com/media/legacy.jpg' }],
-                },
-            },
-            core: { user_results: { result: { legacy: { screen_name: 'dave' } } } },
-        }, new Set());
-        expect(tweet?.has_media).toBe(true);
-        expect(tweet?.media_urls).toEqual(['https://pbs.twimg.com/media/legacy.jpg']);
-    });
-
-    it('prefers note_tweet text over truncated full_text', () => {
-        const tweet = extractBookmarkTweet({
-            rest_id: '2',
-            legacy: { full_text: 'short text…', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
-            note_tweet: { note_tweet_results: { result: { text: 'full long-form text body' } } },
-            core: { user_results: { result: { core: { screen_name: 'erin' } } } },
-        }, new Set());
-        expect(tweet?.text).toBe('full long-form text body');
-    });
-
-    it('deduplicates tweets across the seen Set', () => {
-        const data = {
-            data: {
-                bookmark_timeline_v2: {
-                    timeline: {
-                        instructions: [{
-                            entries: [
-                                {
-                                    entryId: 'tweet-3',
-                                    content: {
-                                        itemContent: {
-                                            tweet_results: {
-                                                result: {
-                                                    rest_id: '3',
-                                                    legacy: { full_text: 'first', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
-                                                    core: { user_results: { result: { legacy: { screen_name: 'frank' } } } },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                                {
-                                    entryId: 'tweet-3-dup',
-                                    content: {
-                                        itemContent: {
-                                            tweet_results: {
-                                                result: {
-                                                    rest_id: '3',
-                                                    legacy: { full_text: 'duplicate' },
-                                                    core: { user_results: { result: { legacy: { screen_name: 'frank' } } } },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        }],
-                    },
-                },
-            },
-        };
-        const seen = new Set();
-        const { tweets } = parseBookmarks(data, seen);
-        expect(tweets).toHaveLength(1);
-        expect(tweets[0].text).toBe('first');
-    });
-
-    it('extracts cursor + tweets from the bookmark_timeline_v2 envelope', () => {
-        const data = {
-            data: {
-                bookmark_timeline_v2: {
-                    timeline: {
-                        instructions: [
-                            {
-                                type: 'TimelineAddEntries',
-                                entries: [
-                                    {
-                                        entryId: 'tweet-4',
-                                        content: {
-                                            itemContent: {
-                                                tweet_results: {
-                                                    result: {
-                                                        rest_id: '4',
-                                                        legacy: {
-                                                            full_text: 'envelope tweet',
-                                                            favorite_count: 1,
-                                                            retweet_count: 0,
-                                                            bookmark_count: 0,
-                                                            extended_entities: {
-                                                                media: [{ type: 'photo', media_url_https: 'https://pbs.twimg.com/media/x.jpg' }],
-                                                            },
-                                                        },
-                                                        core: { user_results: { result: { legacy: { screen_name: 'gina' } } } },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                    {
-                                        entryId: 'cursor-bottom-Y',
-                                        content: { __typename: 'TimelineTimelineCursor', cursorType: 'Bottom', value: 'NEXT' },
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                },
-            },
-        };
-        const { tweets, nextCursor } = parseBookmarks(data, new Set());
-        expect(tweets).toHaveLength(1);
-        expect(tweets[0].id).toBe('4');
-        expect(tweets[0].has_media).toBe(true);
-        expect(tweets[0].media_urls).toEqual(['https://pbs.twimg.com/media/x.jpg']);
-        expect(nextCursor).toBe('NEXT');
-    });
-
-    it('returns empty tweets + null cursor for unknown envelope', () => {
-        expect(parseBookmarks({}, new Set())).toEqual({ tweets: [], nextCursor: null });
-    });
-});

package/clis/twitter/delete.test.js

@@ -1,85 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ArgumentError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import './delete.js';
-describe('twitter delete command', () => {
-    it('targets the matched tweet article instead of the first More button on the page', async () => {
-        const cmd = getRegistry().get('twitter/delete');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({ ok: true, message: 'Tweet successfully deleted.' }),
-        };
-        const result = await cmd.func(page, {
-            url: 'https://x.com/alice/status/2040254679301718161?s=20',
-        });
-        expect(page.goto).toHaveBeenCalledWith('https://x.com/alice/status/2040254679301718161?s=20');
-        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="primaryColumn"]' });
-        expect(page.wait).toHaveBeenNthCalledWith(2, 2);
-        const script = page.evaluate.mock.calls[0][0];
-        // Article-scoping must come from the shared helper (not an inline
-        // `pathname.includes('/status/' + tweetId)` substring match — see
-        // codex-mini0 #1400 catch where `/status/123` would match
-        // `/status/1234567`). The helper emits `__twHasLinkToTarget` and
-        // `__twGetStatusIdFromHref` plus the canonical anchored regex.
-        expect(script).toContain('__twHasLinkToTarget');
-        expect(script).toContain('__twGetStatusIdFromHref');
-        expect(script).toContain("document.querySelectorAll('article')");
-        expect(script).toContain("targetArticle.querySelectorAll('button,[role=\"button\"]')");
-        // Substring match must NOT appear — exact-id match only.
-        expect(script).not.toContain("'/status/' + tweetId");
-        expect(result).toEqual([
-            {
-                status: 'success',
-                message: 'Tweet successfully deleted.',
-            },
-        ]);
-    });
-    it('passes through matched-tweet lookup failures', async () => {
-        const cmd = getRegistry().get('twitter/delete');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = {
-            goto: vi.fn().mockResolvedValue(undefined),
-            wait: vi.fn().mockResolvedValue(undefined),
-            evaluate: vi.fn().mockResolvedValue({
-                ok: false,
-                message: 'Could not find the tweet card matching the requested URL.',
-            }),
-        };
-        const result = await cmd.func(page, {
-            url: 'https://x.com/alice/status/2040254679301718161',
-        });
-        expect(result).toEqual([
-            {
-                status: 'failed',
-                message: 'Could not find the tweet card matching the requested URL.',
-            },
-        ]);
-        expect(page.wait).toHaveBeenCalledTimes(1);
-    });
-    it('rejects malformed or off-domain URLs with ArgumentError before navigation', async () => {
-        const cmd = getRegistry().get('twitter/delete');
-        expect(cmd?.func).toBeTypeOf('function');
-        const page = {
-            goto: vi.fn(),
-            wait: vi.fn(),
-            evaluate: vi.fn(),
-        };
-        // parseTweetUrl bubbles ArgumentError directly (no CommandExecutionError
-        // wrapping); replaces the previous local extractTweetId path that hid
-        // typed-input failures behind a generic CliError.
-        await expect(cmd.func(page, {
-            url: 'https://x.com/alice/home',
-        })).rejects.toThrow(ArgumentError);
-        expect(page.goto).not.toHaveBeenCalled();
-        expect(page.wait).not.toHaveBeenCalled();
-        expect(page.evaluate).not.toHaveBeenCalled();
-    });
-    it('throws CommandExecutionError when no page is provided', async () => {
-        const cmd = getRegistry().get('twitter/delete');
-        await expect(cmd.func(undefined, {
-            url: 'https://x.com/alice/status/2040254679301718161',
-        })).rejects.toThrow(CommandExecutionError);
-    });
-});

package/clis/twitter/device-follow.test.js

@@ -1,287 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './device-follow.js';
-
-const { buildDeviceFollowUrl, extractEntries, joinEntryToTweet, shapeRow, parseDeviceFollow, parseLimit } = await import('./device-follow.js').then((m) => m.__test__);
-
-function tweet(id, userId, overrides = {}) {
-    return {
-        id_str: id,
-        user_id_str: userId,
-        full_text: `text-${id}`,
-        favorite_count: 10,
-        retweet_count: 2,
-        reply_count: 1,
-        quote_count: 0,
-        created_at: 'Sun May 18 12:34:56 +0000 2026',
-        ...overrides,
-    };
-}
-
-function user(id, screenName) {
-    return { id_str: id, screen_name: screenName };
-}
-
-function entry(tweetId) {
-    return {
-        entryId: `tweet-${tweetId}`,
-        content: { item: { content: { tweet: { id: tweetId } } } },
-    };
-}
-
-function nonTweetEntry(id = 'cursor-bottom') {
-    return {
-        entryId: id,
-        content: { item: { content: {} } },
-    };
-}
-
-function payload(tweets, users, entries) {
-    return {
-        globalObjects: { tweets, users },
-        timeline: { id: 'tweet_notifications', instructions: [{ addEntries: { entries } }] },
-    };
-}
-
-describe('twitter device-follow', () => {
-    it('parseLimit accepts 1-200 and rejects everything else without silent clamping', () => {
-        expect(parseLimit(undefined)).toBe(20);
-        expect(parseLimit(1)).toBe(1);
-        expect(parseLimit(200)).toBe(200);
-        expect(() => parseLimit(0)).toThrow(ArgumentError);
-        expect(() => parseLimit(201)).toThrow(ArgumentError);
-        expect(() => parseLimit(1.5)).toThrow(ArgumentError);
-        expect(() => parseLimit('abc')).toThrow(ArgumentError);
-    });
-
-    it('builds the device_follow URL with required v1.1 params', () => {
-        const url = buildDeviceFollowUrl(25);
-        expect(url.startsWith('/i/api/2/notifications/device_follow.json?')).toBe(true);
-        const params = new URLSearchParams(url.split('?')[1]);
-        expect(params.get('count')).toBe('25');
-        expect(params.get('tweet_mode')).toBe('extended');
-        expect(params.get('include_ext_views')).toBe('true');
-        expect(params.get('include_reply_count')).toBe('1');
-        expect(params.get('include_quote_count')).toBe('true');
-    });
-
-    it('extracts entries from the addEntries instruction shape', () => {
-        const p = payload({}, {}, [entry('1'), entry('2')]);
-        const entries = extractEntries(p.timeline);
-        expect(entries).toHaveLength(2);
-        expect(entries[0].entryId).toBe('tweet-1');
-    });
-
-    it('extractEntries tolerates missing or empty instructions', () => {
-        expect(extractEntries(undefined)).toBeNull();
-        expect(extractEntries({})).toBeNull();
-        expect(extractEntries({ instructions: [] })).toEqual([]);
-        expect(extractEntries({ instructions: [{ addEntries: { entries: [] } }] })).toEqual([]);
-    });
-
-    it('joinEntryToTweet pairs the entry tweet id to globalObjects', () => {
-        const tweets = { '1': tweet('1', 'u1') };
-        const users = { u1: user('u1', 'alice') };
-        const out = joinEntryToTweet(entry('1'), tweets, users);
-        expect(out?.tweetId).toBe('1');
-        expect(out?.tweet.full_text).toBe('text-1');
-        expect(out?.user.screen_name).toBe('alice');
-    });
-
-    it('joinEntryToTweet returns null when tweet id is missing or unmatched', () => {
-        expect(joinEntryToTweet({}, {}, {})).toBeNull();
-        expect(joinEntryToTweet(entry('1'), {}, {})).toBeNull();
-    });
-
-    it('shapeRow projects the canonical row schema with views=null', () => {
-        const row = shapeRow({
-            tweetId: '42',
-            tweet: tweet('42', 'u1', { favorite_count: 5, retweet_count: 1, reply_count: 7 }),
-            user: user('u1', 'bob'),
-        });
-        expect(row).toEqual({
-            id: '42',
-            author: 'bob',
-            text: 'text-42',
-            likes: 5,
-            retweets: 1,
-            replies: 7,
-            views: null,
-            created_at: 'Sun May 18 12:34:56 +0000 2026',
-            url: 'https://x.com/bob/status/42',
-        });
-    });
-
-    it('joinEntryToTweet requires a resolved user screen_name before emitting a row URL', () => {
-        expect(joinEntryToTweet(entry('1'), { '1': tweet('1', 'missing') }, {})).toBeNull();
-        expect(joinEntryToTweet(entry('1'), { '1': tweet('1', 'u1') }, { u1: { id_str: 'u1' } })).toBeNull();
-    });
-
-    it('shapeRow uses tweet.text when full_text is absent', () => {
-        const row = shapeRow({ tweetId: '7', tweet: { text: 'fallback' }, user: user('u1', 'x') });
-        expect(row.text).toBe('fallback');
-    });
-
-    it('parseDeviceFollow maps the legacy v1.1 payload to rows', () => {
-        const p = payload(
-            { '1': tweet('1', 'u1'), '2': tweet('2', 'u2') },
-            { u1: user('u1', 'alice'), u2: user('u2', 'bob') },
-            [entry('1'), entry('2')],
-        );
-        const rows = parseDeviceFollow(p, new Set());
-        expect(rows?.rows.map((r) => r.author)).toEqual(['alice', 'bob']);
-        expect(rows?.rows.every((r) => r.views === null)).toBe(true);
-        expect(rows?.rows[0].url).toBe('https://x.com/alice/status/1');
-    });
-
-    it('parseDeviceFollow dedupes via the seen set', () => {
-        const p = payload(
-            { '1': tweet('1', 'u1') },
-            { u1: user('u1', 'alice') },
-            [entry('1'), entry('1')],
-        );
-        expect(parseDeviceFollow(p, new Set())?.rows).toHaveLength(1);
-    });
-
-    it('parseDeviceFollow returns typed empty metadata for the empty-stream shape', () => {
-        const empty = { globalObjects: {}, timeline: { instructions: [{ addEntries: { entries: [] } }] } };
-        expect(parseDeviceFollow(empty, new Set())).toEqual({
-            rows: [],
-            entryCount: 0,
-            unmatchedTweetEntries: 0,
-            malformedEntries: 0,
-        });
-    });
-
-    it('parseDeviceFollow returns null for malformed top-level shape', () => {
-        expect(parseDeviceFollow({}, new Set())).toBeNull();
-        expect(parseDeviceFollow({ globalObjects: {}, timeline: {} }, new Set())).toBeNull();
-    });
-
-    it('parseDeviceFollow tracks tweet entries that cannot join to required user identity', () => {
-        const parsed = parseDeviceFollow(payload({ '1': tweet('1', 'u1') }, {}, [entry('1')]), new Set());
-        expect(parsed).toMatchObject({
-            rows: [],
-            entryCount: 1,
-            unmatchedTweetEntries: 1,
-            malformedEntries: 0,
-        });
-    });
-
-    it('parseDeviceFollow tracks non-empty entries without tweet identity as parser drift', () => {
-        const parsed = parseDeviceFollow(payload({}, {}, [nonTweetEntry()]), new Set());
-        expect(parsed).toMatchObject({
-            rows: [],
-            entryCount: 1,
-            unmatchedTweetEntries: 0,
-            malformedEntries: 1,
-        });
-    });
-
-    it('registers with the canonical twitter row columns (minus has_media/media_urls/card)', () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        expect(cmd?.columns).toEqual(['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url']);
-        expect(cmd?.browser).toBe(true);
-    });
-
-    it('throws AuthRequiredError when ct0 cookie is missing', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'other', value: 'x' }]),
-            evaluate: vi.fn(),
-        };
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws CommandExecutionError on non-2xx response', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
-            evaluate: vi.fn().mockResolvedValue({ error: 401 }),
-        };
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-
-    it('throws CommandExecutionError on non-auth non-2xx response', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
-            evaluate: vi.fn().mockResolvedValue({ error: 500 }),
-        };
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws CommandExecutionError on browser fetch/json exceptions', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const cookies = [{ name: 'ct0', value: 'token' }];
-        await expect(cmd.func({
-            getCookies: vi.fn().mockResolvedValue(cookies),
-            evaluate: vi.fn().mockResolvedValue({ errorKind: 'non_json', detail: 'Unexpected token <' }),
-        }, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(cmd.func({
-            getCookies: vi.fn().mockResolvedValue(cookies),
-            evaluate: vi.fn().mockResolvedValue({ errorKind: 'exception', detail: 'network failed' }),
-        }, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('throws EmptyResultError for a valid empty device-follow stream', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
-            evaluate: vi.fn().mockResolvedValue(payload({}, {}, [])),
-        };
-        await expect(cmd.func(page, { limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('throws CommandExecutionError for malformed or unjoinable device-follow payloads', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const cookies = [{ name: 'ct0', value: 'token' }];
-        await expect(cmd.func({
-            getCookies: vi.fn().mockResolvedValue(cookies),
-            evaluate: vi.fn().mockResolvedValue({}),
-        }, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(cmd.func({
-            getCookies: vi.fn().mockResolvedValue(cookies),
-            evaluate: vi.fn().mockResolvedValue(payload({ '1': tweet('1', 'u1') }, {}, [entry('1')])),
-        }, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-        await expect(cmd.func({
-            getCookies: vi.fn().mockResolvedValue(cookies),
-            evaluate: vi.fn().mockResolvedValue(payload({}, {}, [nonTweetEntry()])),
-        }, { limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('returns parsed rows when the fetch succeeds', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const p = payload(
-            { '1': tweet('1', 'u1'), '2': tweet('2', 'u2') },
-            { u1: user('u1', 'alice'), u2: user('u2', 'bob') },
-            [entry('1'), entry('2')],
-        );
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
-            evaluate: vi.fn().mockResolvedValue(p),
-        };
-        const rows = await cmd.func(page, { limit: 5 });
-        expect(rows).toHaveLength(2);
-        expect(rows[0].author).toBe('alice');
-    });
-
-    it('respects --limit when the upstream returns more than asked', async () => {
-        const cmd = getRegistry().get('twitter/device-follow');
-        const tweets = {};
-        const users = {};
-        const entries = [];
-        for (let i = 1; i <= 10; i++) {
-            tweets[String(i)] = tweet(String(i), `u${i}`);
-            users[`u${i}`] = user(`u${i}`, `user${i}`);
-            entries.push(entry(String(i)));
-        }
-        const page = {
-            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
-            evaluate: vi.fn().mockResolvedValue(payload(tweets, users, entries)),
-        };
-        const rows = await cmd.func(page, { limit: 3 });
-        expect(rows).toHaveLength(3);
-    });
-});