@jackwener/opencli 1.7.13 → 1.7.15

package/clis/twitter/bookmark-folder.js

@@ -0,0 +1,189 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
+import { resolveTwitterQueryId } from './shared.js';
+
+// Companion to bookmark-folders.js: reads tweets inside a single folder.
+// X exposes folder contents through a separate timeline operation
+// (BookmarkFolderTimeline). The shape is essentially the same as the
+// global bookmarks timeline (bookmark_timeline_v2.timeline.instructions),
+// just scoped to one folder via the bookmark_collection_id variable.
+const OPERATION_NAME = 'BookmarkFolderTimeline';
+const FALLBACK_QUERY_ID = '13H7EUATwethsj_jZ6QQAQ';
+const FOLDER_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+
+const FEATURES = {
+    rweb_video_screen_enabled: false,
+    profile_label_improvements_pcf_label_in_post_enabled: true,
+    responsive_web_profile_redirect_enabled: false,
+    rweb_tipjar_consumption_enabled: false,
+    verified_phone_label_enabled: false,
+    creator_subscriptions_tweet_preview_api_enabled: true,
+    responsive_web_graphql_timeline_navigation_enabled: true,
+    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+    premium_content_api_read_enabled: false,
+    communities_web_enable_tweet_community_results_fetch: true,
+    c9s_tweet_anatomy_moderator_badge_enabled: true,
+    articles_preview_enabled: true,
+    responsive_web_edit_tweet_api_enabled: true,
+    graphql_is_translatable_rweb_tweet_is_translatable_enabled: true,
+    view_counts_everywhere_api_enabled: true,
+    longform_notetweets_consumption_enabled: true,
+    responsive_web_twitter_article_tweet_consumption_enabled: true,
+    tweet_awards_web_tipping_enabled: false,
+    content_disclosure_indicator_enabled: true,
+    content_disclosure_ai_generated_indicator_enabled: true,
+    freedom_of_speech_not_reach_fetch_enabled: true,
+    standardized_nudges_misinfo: true,
+    tweet_with_visibility_results_prefer_gql_limited_actions_policy_enabled: true,
+    longform_notetweets_rich_text_read_enabled: true,
+    longform_notetweets_inline_media_enabled: false,
+    responsive_web_enhance_cards_enabled: false,
+};
+
+function buildFolderTimelineUrl(queryId, folderId, count, cursor) {
+    const vars = {
+        bookmark_collection_id: String(folderId),
+        count,
+        includePromotedContent: false,
+    };
+    if (cursor) vars.cursor = cursor;
+    return `/i/api/graphql/${queryId}/${OPERATION_NAME}`
+        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+
+function extractFolderTweet(result, seen) {
+    if (!result) return null;
+    const tw = result.tweet || result;
+    const legacy = tw.legacy || {};
+    if (!tw.rest_id || seen.has(tw.rest_id)) return null;
+    seen.add(tw.rest_id);
+    const user = tw.core?.user_results?.result;
+    const screenName = user?.legacy?.screen_name || user?.core?.screen_name || '';
+    const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+    return {
+        id: tw.rest_id,
+        author: screenName,
+        text: noteText || legacy.full_text || '',
+        likes: legacy.favorite_count || 0,
+        retweets: legacy.retweet_count || 0,
+        bookmarks: legacy.bookmark_count || 0,
+        created_at: legacy.created_at || '',
+        url: screenName ? `https://x.com/${screenName}/status/${tw.rest_id}` : `https://x.com/i/status/${tw.rest_id}`,
+    };
+}
+
+/**
+ * Parse the bookmark-folder timeline payload. Same instruction-walking
+ * pattern as the global bookmarks timeline; X re-uses the
+ * `bookmark_timeline_v2` envelope for folder-scoped queries.
+ *
+ * Exported via __test__.
+ */
+export function parseBookmarkFolderTimeline(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    const instructions = data?.data?.bookmark_collection_timeline?.timeline?.instructions
+        || data?.data?.bookmark_timeline_v2?.timeline?.instructions
+        || data?.data?.bookmark_timeline?.timeline?.instructions
+        || [];
+    for (const inst of instructions) {
+        for (const entry of inst.entries || []) {
+            const content = entry.content;
+            if (content?.entryType === 'TimelineTimelineCursor' || content?.__typename === 'TimelineTimelineCursor') {
+                if (content.cursorType === 'Bottom' || content.cursorType === 'ShowMore')
+                    nextCursor = content.value;
+                continue;
+            }
+            if (entry.entryId?.startsWith('cursor-bottom-') || entry.entryId?.startsWith('cursor-showMore-')) {
+                nextCursor = content?.value || content?.itemContent?.value || nextCursor;
+                continue;
+            }
+            const direct = extractFolderTweet(content?.itemContent?.tweet_results?.result, seen);
+            if (direct) {
+                tweets.push(direct);
+                continue;
+            }
+            for (const item of content?.items || []) {
+                const nested = extractFolderTweet(item.item?.itemContent?.tweet_results?.result, seen);
+                if (nested) tweets.push(nested);
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+
+cli({
+    site: 'twitter',
+    name: 'bookmark-folder',
+    access: 'read',
+    description: 'Read the tweets inside a single Twitter/X bookmark folder. Get the folder id from `opencli twitter bookmark-folders`.',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'folder-id', positional: true, type: 'string', required: true, help: 'Folder id from `opencli twitter bookmark-folders`.' },
+        { name: 'limit', type: 'int', default: 20, help: 'Maximum number of bookmarks to return (default 20).' },
+        { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the folder by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the API\'s native (saved-time) ordering.' },
+    ],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'bookmarks', 'created_at', 'url'],
+    func: async (page, kwargs) => {
+        const folderId = String(kwargs['folder-id'] || '').trim();
+        if (!folderId || !FOLDER_ID_PATTERN.test(folderId)) {
+            throw new ArgumentError(
+                `Invalid folder-id: ${JSON.stringify(kwargs['folder-id'])}. Expected a safe folder ID from \`opencli twitter bookmark-folders\`.`,
+            );
+        }
+        const limit = Number(kwargs.limit ?? 20);
+        if (!Number.isInteger(limit) || limit < 1) {
+            throw new ArgumentError(`Invalid --limit: ${JSON.stringify(kwargs.limit)}. Expected a positive integer.`);
+        }
+
+        await page.goto('https://x.com');
+        await page.wait(3);
+        const ct0 = await page.evaluate(`() => {
+            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
+        }`);
+        if (!ct0)
+            throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
+
+        const queryId = await resolveTwitterQueryId(page, OPERATION_NAME, FALLBACK_QUERY_ID);
+
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+
+        const allTweets = [];
+        const seen = new Set();
+        let cursor = null;
+        for (let i = 0; i < 5 && allTweets.length < limit; i++) {
+            const fetchCount = Math.min(100, limit - allTweets.length + 10);
+            const apiUrl = buildFolderTimelineUrl(queryId, folderId, fetchCount, cursor);
+            const data = await page.evaluate(`async () => {
+                const r = await fetch(${JSON.stringify(apiUrl)}, { headers: ${headers}, credentials: 'include' });
+                return r.ok ? await r.json() : { error: r.status };
+            }`);
+            if (data?.error) {
+                if (allTweets.length === 0)
+                    throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch folder ${folderId}. queryId may have expired, or the folder may not exist.`);
+                break;
+            }
+            const { tweets, nextCursor } = parseBookmarkFolderTimeline(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor) break;
+            cursor = nextCursor;
+        }
+        const trimmed = allTweets.slice(0, limit);
+        return applyTopByEngagement(trimmed, kwargs['top-by-engagement']);
+    },
+});
+
+export const __test__ = {
+    parseBookmarkFolderTimeline,
+    buildFolderTimelineUrl,
+    FOLDER_ID_PATTERN,
+};

package/clis/twitter/bookmark-folder.test.js

@@ -0,0 +1,334 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './bookmark-folder.js';
+
+const { parseBookmarkFolderTimeline, buildFolderTimelineUrl, FOLDER_ID_PATTERN } = __test__;
+
+describe('twitter bookmark-folder URL builder', () => {
+    it('embeds the folder id and count in the variables payload', () => {
+        const url = buildFolderTimelineUrl('queryX', '12345', 50, null);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('12345');
+        expect(vars.count).toBe(50);
+        expect(vars.includePromotedContent).toBe(false);
+        expect(vars.cursor).toBeUndefined();
+    });
+
+    it('appends the cursor when one is supplied', () => {
+        const url = buildFolderTimelineUrl('queryX', '12345', 50, 'CURSOR_VAL');
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.cursor).toBe('CURSOR_VAL');
+    });
+
+    it('coerces a numeric folder id to a string', () => {
+        const url = buildFolderTimelineUrl('queryX', 555, 10);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('555');
+    });
+
+    it('preserves opaque folder ids without truncating them', () => {
+        const url = buildFolderTimelineUrl('queryX', 'folder_AbC-123', 10);
+        const m = url.match(/variables=([^&]+)/);
+        const vars = JSON.parse(decodeURIComponent(m[1]));
+        expect(vars.bookmark_collection_id).toBe('folder_AbC-123');
+    });
+});
+
+describe('twitter bookmark-folder timeline parser', () => {
+    it('extracts tweets from bookmark_timeline_v2 envelope', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [
+                            {
+                                type: 'TimelineAddEntries',
+                                entries: [
+                                    {
+                                        entryId: 'tweet-1',
+                                        content: {
+                                            itemContent: {
+                                                tweet_results: {
+                                                    result: {
+                                                        rest_id: '1',
+                                                        legacy: {
+                                                            full_text: 'first folder tweet',
+                                                            favorite_count: 9,
+                                                            retweet_count: 2,
+                                                            bookmark_count: 3,
+                                                            created_at: 'Tue Mar 17 09:00:00 +0000 2026',
+                                                        },
+                                                        core: {
+                                                            user_results: {
+                                                                result: { core: { screen_name: 'alice' } },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                    {
+                                        entryId: 'cursor-bottom-X',
+                                        content: {
+                                            __typename: 'TimelineTimelineCursor',
+                                            cursorType: 'Bottom',
+                                            value: 'NEXT_CURSOR',
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const { tweets, nextCursor } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets).toEqual([
+            {
+                id: '1',
+                author: 'alice',
+                text: 'first folder tweet',
+                likes: 9,
+                retweets: 2,
+                bookmarks: 3,
+                created_at: 'Tue Mar 17 09:00:00 +0000 2026',
+                url: 'https://x.com/alice/status/1',
+            },
+        ]);
+        expect(nextCursor).toBe('NEXT_CURSOR');
+    });
+
+    it('falls back to bookmark_collection_timeline envelope', () => {
+        const data = {
+            data: {
+                bookmark_collection_timeline: {
+                    timeline: {
+                        instructions: [
+                            {
+                                entries: [
+                                    {
+                                        entryId: 'tweet-2',
+                                        content: {
+                                            itemContent: {
+                                                tweet_results: {
+                                                    result: {
+                                                        rest_id: '2',
+                                                        legacy: { full_text: 'collection envelope', favorite_count: 1, retweet_count: 0, bookmark_count: 0 },
+                                                        core: { user_results: { result: { legacy: { screen_name: 'bob' } } } },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets).toHaveLength(1);
+        expect(tweets[0].id).toBe('2');
+        expect(tweets[0].author).toBe('bob');
+    });
+
+    it('uses note_tweet text when present (long-form tweets)', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'tweet-3',
+                                content: {
+                                    itemContent: {
+                                        tweet_results: {
+                                            result: {
+                                                rest_id: '3',
+                                                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' } } },
+                                                core: { user_results: { result: { core: { screen_name: 'carol' } } } },
+                                            },
+                                        },
+                                    },
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets[0].text).toBe('full long-form text');
+    });
+
+    it('deduplicates tweets across the seen Set', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [
+                                {
+                                    entryId: 'tweet-4',
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '4',
+                                                    legacy: { full_text: 'first', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
+                                                    core: { user_results: { result: { core: { screen_name: 'dan' } } } },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                                {
+                                    entryId: 'tweet-4-dup',
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '4',
+                                                    legacy: { full_text: 'duplicate' },
+                                                    core: { user_results: { result: { core: { screen_name: 'dan' } } } },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        }],
+                    },
+                },
+            },
+        };
+        const seen = new Set();
+        const { tweets } = parseBookmarkFolderTimeline(data, seen);
+        expect(tweets).toHaveLength(1);
+        expect(tweets[0].text).toBe('first');
+    });
+
+    it('does not synthesize an unknown author sentinel when screen_name is missing', () => {
+        const data = {
+            data: {
+                bookmark_timeline_v2: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'tweet-5',
+                                content: {
+                                    itemContent: {
+                                        tweet_results: {
+                                            result: {
+                                                rest_id: '5',
+                                                legacy: { full_text: 'missing author', favorite_count: 0, retweet_count: 0, bookmark_count: 0 },
+                                                core: { user_results: { result: {} } },
+                                            },
+                                        },
+                                    },
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        };
+        const { tweets } = parseBookmarkFolderTimeline(data, new Set());
+        expect(tweets[0].author).toBe('');
+        expect(tweets[0].url).toBe('https://x.com/i/status/5');
+    });
+
+    it('returns empty array + null cursor for unknown envelope', () => {
+        expect(parseBookmarkFolderTimeline({}, new Set())).toEqual({ tweets: [], nextCursor: null });
+    });
+});
+
+describe('twitter bookmark-folder id validation', () => {
+    it('accepts numeric and opaque safe ids from bookmark-folders output', () => {
+        expect(FOLDER_ID_PATTERN.test('1234567890')).toBe(true);
+        expect(FOLDER_ID_PATTERN.test('folder_AbC-123')).toBe(true);
+    });
+
+    it('rejects ids that could pollute GraphQL variables or URL construction', () => {
+        for (const value of ['folder/123', 'folder?x=1', 'folder%2F123', 'folder.123', 'folder 123', '']) {
+            expect(FOLDER_ID_PATTERN.test(value)).toBe(false);
+        }
+    });
+});
+
+describe('twitter bookmark-folder command (registry)', () => {
+    it('throws ArgumentError on unsafe folder-id before navigation', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        expect(command?.func).toBeTypeOf('function');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            evaluate: vi.fn(),
+        };
+        await expect(command.func(page, { 'folder-id': 'folder/123', limit: 5 }))
+            .rejects
+            .toThrow(/Invalid folder-id/);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('throws ArgumentError on empty folder-id', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            evaluate: vi.fn(),
+        };
+        await expect(command.func(page, { 'folder-id': '   ', limit: 5 }))
+            .rejects
+            .toThrow(/Invalid folder-id/);
+    });
+
+    it('throws ArgumentError on invalid limit before navigation', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        for (const limit of [0, -1, 1.5, Number.NaN]) {
+            const page = {
+                goto: vi.fn(),
+                wait: vi.fn(),
+                evaluate: vi.fn(),
+            };
+            await expect(command.func(page, { 'folder-id': '12345', limit }))
+                .rejects
+                .toThrow(/Invalid --limit/);
+            expect(page.goto).not.toHaveBeenCalled();
+        }
+    });
+
+    it('throws AuthRequiredError when ct0 cookie is missing', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn().mockResolvedValue(null),
+        };
+        await expect(command.func(page, { 'folder-id': '12345', limit: 5 }))
+            .rejects
+            .toThrow(/Not logged into x.com/);
+    });
+
+    it('accepts an opaque safe folder-id and sends it in the GraphQL variables', async () => {
+        const command = getRegistry().get('twitter/bookmark-folder');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce('ct0-token')
+                .mockResolvedValueOnce('queryX')
+                .mockResolvedValueOnce({ data: { bookmark_timeline_v2: { timeline: { instructions: [] } } } }),
+        };
+        const result = await command.func(page, { 'folder-id': 'folder_AbC-123', limit: 5 });
+        expect(result).toEqual([]);
+        const fetchScript = page.evaluate.mock.calls[2][0];
+        expect(decodeURIComponent(fetchScript)).toContain('"bookmark_collection_id":"folder_AbC-123"');
+    });
+});

package/clis/twitter/bookmark-folders.js

@@ -0,0 +1,117 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { TWITTER_BEARER_TOKEN } from './utils.js';
+import { resolveTwitterQueryId } from './shared.js';
+
+// X surfaces user-created bookmark folders through a GraphQL slice query.
+// We mirror the patterns used in bookmarks.js / lists.js: a literal
+// fallback queryId combined with a runtime lookup against the
+// twitter-openapi placeholder.json so we keep working when X rotates IDs.
+const OPERATION_NAME = 'bookmarkFoldersSlice';
+const FALLBACK_QUERY_ID = 'i78YDd0Tza-dWKw5H2Y7WA';
+
+const FEATURES = {
+    rweb_tipjar_consumption_enabled: false,
+    responsive_web_graphql_exclude_directive_enabled: true,
+    verified_phone_label_enabled: false,
+    creator_subscriptions_tweet_preview_api_enabled: true,
+    responsive_web_graphql_timeline_navigation_enabled: true,
+    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+};
+
+function buildUrl(queryId) {
+    const variables = JSON.stringify({});
+    return `/i/api/graphql/${queryId}/${OPERATION_NAME}`
+        + `?variables=${encodeURIComponent(variables)}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+
+/**
+ * Walk the GraphQL response shape used by X's bookmark folders slice and
+ * project each folder onto our column row.
+ *
+ * X has shipped at least three different envelope shapes for this query
+ * across the last two years; the precedence order below preserves
+ * compatibility with older accounts whose Premium-eligibility flag is
+ * still on the legacy V2 envelope.
+ *
+ * Exported via __test__ so the parser is unit-testable without a browser.
+ */
+export function parseBookmarkFolders(data, seen) {
+    const folders = [];
+    const slice = data?.data?.viewer?.bookmark_collections_slice
+        || data?.data?.viewer_v2?.user_results?.result?.bookmark_collections_slice
+        || data?.data?.bookmark_collections_slice
+        || null;
+    const items = slice?.items || slice?.timeline?.timeline?.instructions?.flatMap?.(i => i.entries || []) || [];
+    for (const item of items) {
+        // Two known item shapes: direct {id, name, ...} (newer) or wrapped
+        // {content: {bookmarkCollectionResult: {...}}} (older / nested).
+        const folder
+            = item?.bookmarkCollection
+            || item?.content?.bookmarkCollection
+            || item?.content?.itemContent?.bookmark_collection
+            || item;
+        const id = folder?.id_str || folder?.id || folder?.rest_id || '';
+        if (!id || seen.has(id)) continue;
+        seen.add(id);
+        const name = folder?.name || folder?.collection_name || '';
+        // bookmarks_count is the X UI label; older envelopes used `count`.
+        const itemsCount = Number(folder?.bookmarks_count ?? folder?.items_count ?? folder?.count ?? 0) || 0;
+        const createdAt = folder?.created_at || folder?.timestamp_ms || '';
+        folders.push({
+            id: String(id),
+            name: String(name),
+            items: itemsCount,
+            created_at: String(createdAt),
+        });
+    }
+    return folders;
+}
+
+cli({
+    site: 'twitter',
+    name: 'bookmark-folders',
+    access: 'read',
+    description: 'List your Twitter/X bookmark folders (the user-created collections under Bookmarks). Returns folder id, name, item count, and created_at.',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [],
+    columns: ['id', 'name', 'items', 'created_at'],
+    func: async (page) => {
+        await page.goto('https://x.com');
+        await page.wait(3);
+        const ct0 = await page.evaluate(`() => {
+            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
+        }`);
+        if (!ct0)
+            throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
+
+        // Try the fa0311/twitter-openapi placeholder first; fall back to scraping
+        // client-web bundles for the queryId; final fallback is the pinned constant.
+        const queryId = await resolveTwitterQueryId(page, OPERATION_NAME, FALLBACK_QUERY_ID);
+
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+        const apiUrl = buildUrl(queryId);
+        const data = await page.evaluate(`async () => {
+            const r = await fetch(${JSON.stringify(apiUrl)}, { headers: ${headers}, credentials: 'include' });
+            return r.ok ? await r.json() : { error: r.status };
+        }`);
+        if (data?.error) {
+            throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch bookmark folders. queryId may have expired, or your account may not have folder access.`);
+        }
+        const seen = new Set();
+        return parseBookmarkFolders(data, seen);
+    },
+});
+
+export const __test__ = {
+    parseBookmarkFolders,
+    buildUrl,
+};