@jackwener/opencli 1.7.4 → 1.7.6

package/clis/twitter/list-tweets.js

@@ -0,0 +1,185 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const LIST_TWEETS_QUERY_ID = 'RlZzktZY_9wJynoepm8ZsA';
+const OPERATION_NAME = 'ListLatestTweetsTimeline';
+
+const FEATURES = {
+    rweb_video_screen_enabled: false,
+    profile_label_improvements_pcf_label_in_post_enabled: true,
+    rweb_tipjar_consumption_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,
+    premium_content_api_read_enabled: false,
+    communities_web_enable_tweet_community_results_fetch: true,
+    c9s_tweet_anatomy_moderator_badge_enabled: true,
+    responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+    responsive_web_grok_analyze_post_followups_enabled: true,
+    responsive_web_jetfuel_frame: false,
+    responsive_web_grok_share_attachment_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,
+    responsive_web_grok_show_grok_translated_post: false,
+    responsive_web_grok_analysis_button_from_backend: false,
+    creator_subscriptions_quote_tweet_preview_enabled: false,
+    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: true,
+    responsive_web_grok_image_annotation_enabled: true,
+    responsive_web_enhance_cards_enabled: false,
+};
+
+function buildUrl(queryId, listId, count, cursor) {
+    const vars = { listId: String(listId), count };
+    if (cursor)
+        vars.cursor = cursor;
+    return `/i/api/graphql/${queryId}/${OPERATION_NAME}`
+        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+
+export function extractTimelineTweet(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 || 'unknown';
+    const displayName = user?.legacy?.name || user?.core?.name || '';
+    const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+    return {
+        id: tw.rest_id,
+        author: screenName,
+        name: displayName,
+        text: noteText || legacy.full_text || '',
+        likes: legacy.favorite_count || 0,
+        retweets: legacy.retweet_count || 0,
+        replies: legacy.reply_count || 0,
+        created_at: legacy.created_at || '',
+        url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+    };
+}
+
+export function parseListTimeline(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    const instructions = data?.data?.list?.tweets_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 = extractTimelineTweet(content?.itemContent?.tweet_results?.result, seen);
+            if (direct) {
+                tweets.push(direct);
+                continue;
+            }
+            for (const item of content?.items || []) {
+                const nested = extractTimelineTweet(item.item?.itemContent?.tweet_results?.result, seen);
+                if (nested)
+                    tweets.push(nested);
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+
+cli({
+    site: 'twitter',
+    name: 'list-tweets',
+    description: 'Fetch tweets from a Twitter/X list timeline',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'listId', positional: true, type: 'string', required: true },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url'],
+    func: async (page, kwargs) => {
+        const listId = String(kwargs.listId || '').trim();
+        if (!listId || !/^\d+$/.test(listId)) {
+            throw new CommandExecutionError(`Invalid listId: ${JSON.stringify(kwargs.listId)}. Expected a numeric ID (see \`opencli twitter lists\`).`);
+        }
+        const limit = kwargs.limit || 50;
+        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 page.evaluate(`async () => {
+            try {
+                const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
+                if (ghResp.ok) {
+                    const data = await ghResp.json();
+                    const entry = data['${OPERATION_NAME}'];
+                    if (entry && entry.queryId) return entry.queryId;
+                }
+            } catch {}
+            try {
+                const scripts = performance.getEntriesByType('resource')
+                    .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))
+                    .map(r => r.name);
+                for (const scriptUrl of scripts.slice(0, 15)) {
+                    try {
+                        const text = await (await fetch(scriptUrl)).text();
+                        const re = /queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"${OPERATION_NAME}"/;
+                        const m = text.match(re);
+                        if (m) return m[1];
+                    } catch {}
+                }
+            } catch {}
+            return null;
+        }`) || LIST_TWEETS_QUERY_ID;
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(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 < 10 && allTweets.length < limit; i++) {
+            const fetchCount = Math.min(100, limit - allTweets.length + 10);
+            const apiUrl = buildUrl(queryId, listId, 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 list timeline. queryId may have expired or list may be private.`);
+                break;
+            }
+            const { tweets, nextCursor } = parseListTimeline(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor || tweets.length === 0)
+                break;
+            cursor = nextCursor;
+        }
+        return allTweets.slice(0, limit);
+    },
+});

package/clis/twitter/list-tweets.test.js

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+import { extractTimelineTweet, parseListTimeline } from './list-tweets.js';
+
+describe('twitter list-tweets parser', () => {
+    it('extracts core tweet fields from a ListLatestTweetsTimeline result', () => {
+        const tweet = extractTimelineTweet({
+            rest_id: '99',
+            legacy: {
+                full_text: 'hello list',
+                favorite_count: 3,
+                retweet_count: 1,
+                reply_count: 2,
+                created_at: 'Wed Apr 16 10:00:00 +0000 2026',
+            },
+            core: {
+                user_results: {
+                    result: {
+                        legacy: { screen_name: 'bob', name: 'Bob' },
+                    },
+                },
+            },
+        }, new Set());
+        expect(tweet).toEqual({
+            id: '99',
+            author: 'bob',
+            name: 'Bob',
+            text: 'hello list',
+            likes: 3,
+            retweets: 1,
+            replies: 2,
+            created_at: 'Wed Apr 16 10:00:00 +0000 2026',
+            url: 'https://x.com/bob/status/99',
+        });
+    });
+
+    it('prefers long-form note_tweet text over truncated legacy full_text', () => {
+        const tweet = extractTimelineTweet({
+            rest_id: '100',
+            legacy: { full_text: 'short…' },
+            note_tweet: {
+                note_tweet_results: {
+                    result: { text: 'the full long-form body' },
+                },
+            },
+            core: { user_results: { result: { legacy: { screen_name: 'carol' } } } },
+        }, new Set());
+        expect(tweet?.text).toBe('the full long-form body');
+    });
+
+    it('deduplicates on rest_id', () => {
+        const seen = new Set();
+        const first = extractTimelineTweet({ rest_id: '1', legacy: {}, core: {} }, seen);
+        const second = extractTimelineTweet({ rest_id: '1', legacy: {}, core: {} }, seen);
+        expect(first).not.toBeNull();
+        expect(second).toBeNull();
+    });
+
+    it('parses entries and bottom cursor from the list timeline payload', () => {
+        const payload = {
+            data: {
+                list: {
+                    tweets_timeline: {
+                        timeline: {
+                            instructions: [
+                                {
+                                    entries: [
+                                        {
+                                            entryId: 'tweet-1',
+                                            content: {
+                                                itemContent: {
+                                                    tweet_results: {
+                                                        result: {
+                                                            rest_id: '1',
+                                                            legacy: { full_text: 't1' },
+                                                            core: { user_results: { result: { legacy: { screen_name: 'a' } } } },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                        {
+                                            entryId: 'cursor-bottom-1',
+                                            content: {
+                                                entryType: 'TimelineTimelineCursor',
+                                                cursorType: 'Bottom',
+                                                value: 'cursor-next',
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const result = parseListTimeline(payload, new Set());
+        expect(result.nextCursor).toBe('cursor-next');
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({ id: '1', author: 'a', text: 't1' });
+    });
+
+    it('returns empty tweets and null cursor for malformed payload', () => {
+        const result = parseListTimeline({}, new Set());
+        expect(result.tweets).toEqual([]);
+        expect(result.nextCursor).toBeNull();
+    });
+});

package/clis/twitter/lists.js

@@ -1,62 +1,149 @@
-import { AuthRequiredError, SelectorError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { isEmptyListsState, parseListCards } from './lists-parser.js';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 
-cli({
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const LISTS_QUERY_ID = '78UbkyXwXBD98IgUWXOy9g';
+const OPERATION_NAME = 'ListsManagementPageTimeline';
+
+const FEATURES = {
+    rweb_video_screen_enabled: false,
+    profile_label_improvements_pcf_label_in_post_enabled: true,
+    rweb_tipjar_consumption_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,
+    premium_content_api_read_enabled: false,
+    communities_web_enable_tweet_community_results_fetch: true,
+    c9s_tweet_anatomy_moderator_badge_enabled: true,
+    responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+    responsive_web_grok_analyze_post_followups_enabled: true,
+    responsive_web_jetfuel_frame: false,
+    responsive_web_grok_share_attachment_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,
+    responsive_web_grok_show_grok_translated_post: false,
+    responsive_web_grok_analysis_button_from_backend: false,
+    creator_subscriptions_quote_tweet_preview_enabled: false,
+    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: true,
+    responsive_web_grok_image_annotation_enabled: true,
+    responsive_web_enhance_cards_enabled: false,
+};
+
+function buildUrl(queryId) {
+    return `/i/api/graphql/${queryId}/${OPERATION_NAME}`
+        + `?features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+
+export function extractListEntry(entry, seen) {
+    const list = entry?.content?.itemContent?.list
+        || entry?.content?.list
+        || entry?.item?.itemContent?.list;
+    if (!list) return null;
+    const id = list.id_str || list.id || '';
+    if (!id || seen.has(id)) return null;
+    seen.add(id);
+    const mode = typeof list.mode === 'string' && /private/i.test(list.mode) ? 'private' : 'public';
+    return {
+        id: String(id),
+        name: list.name || '',
+        members: String(list.member_count ?? 0),
+        followers: String(list.subscriber_count ?? 0),
+        mode,
+    };
+}
+
+export function parseListsManagement(data, seen) {
+    const lists = [];
+    const instructions = data?.data?.viewer?.list_management_timeline?.timeline?.instructions
+        || data?.data?.viewer_v2?.user_results?.result?.list_management_timeline?.timeline?.instructions
+        || data?.data?.list_management_timeline?.timeline?.instructions
+        || [];
+    for (const inst of instructions) {
+        for (const entry of inst.entries || []) {
+            const direct = extractListEntry(entry, seen);
+            if (direct) {
+                lists.push(direct);
+                continue;
+            }
+            for (const item of entry?.content?.items || []) {
+                const nested = extractListEntry(item, seen);
+                if (nested) lists.push(nested);
+            }
+        }
+    }
+    return lists;
+}
+
+export const command = cli({
     site: 'twitter',
     name: 'lists',
-    description: 'Get Twitter/X lists for a user',
+    description: 'Get Twitter/X lists for the logged-in user (owned + subscribed)',
     domain: 'x.com',
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'user', positional: true, type: 'string', required: false },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['name', 'members', 'followers', 'mode'],
+    columns: ['id', 'name', 'members', 'followers', 'mode'],
     func: async (page, kwargs) => {
-        let targetUser = kwargs.user;
-        if (!targetUser) {
-            await page.goto('https://x.com/home');
-            await page.wait({ selector: '[data-testid="primaryColumn"]' });
-            const href = await page.evaluate(`() => {
-            const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
-            return link ? link.getAttribute('href') : null;
-        }`);
-            if (!href) {
-                throw new AuthRequiredError('x.com', 'Could not find logged-in user profile link. Are you logged in?');
-            }
-            targetUser = href.replace('/', '');
-        }
-        await page.goto(`https://x.com/${targetUser}/lists`);
+        const limit = kwargs.limit || 50;
+        await page.goto('https://x.com');
         await page.wait(3);
-        const pageData = await page.evaluate(`() => {
-            const cards = [];
-            const seen = new Set();
-            for (const anchor of Array.from(document.querySelectorAll('a[href*="/i/lists/"]'))) {
-                const href = anchor.getAttribute('href') || '';
-                if (!/\\/i\\/lists\\/\\d+/.test(href) || seen.has(href)) continue;
-                seen.add(href);
-                const container = anchor.closest('[data-testid="cellInnerDiv"]') || anchor;
-                const text = (container.innerText || anchor.innerText || '').trim();
-                if (!text) continue;
-                cards.push({ href, text });
-            }
-            return {
-                cards,
-                pageText: document.body.innerText || '',
-            };
+        const ct0 = await page.evaluate(`() => {
+            return document.cookie.split(';').map(c => c.trim()).find(c => c.startsWith('ct0='))?.split('=')[1] || null;
         }`);
-        if (!pageData?.pageText) {
-            throw new SelectorError('Twitter lists', 'Empty page text');
-        }
-        const results = parseListCards(pageData.cards);
-        if (results.length === 0) {
-            if (isEmptyListsState(pageData.pageText)) {
-                return [];
-            }
-            throw new SelectorError('Twitter lists', `Could not parse list data`);
+        if (!ct0)
+            throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
+        const queryId = await page.evaluate(`async () => {
+            try {
+                const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
+                if (ghResp.ok) {
+                    const data = await ghResp.json();
+                    const entry = data['${OPERATION_NAME}'];
+                    if (entry && entry.queryId) return entry.queryId;
+                }
+            } catch {}
+            try {
+                const scripts = performance.getEntriesByType('resource')
+                    .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))
+                    .map(r => r.name);
+                for (const scriptUrl of scripts.slice(0, 15)) {
+                    try {
+                        const text = await (await fetch(scriptUrl)).text();
+                        const re = /queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"${OPERATION_NAME}"/;
+                        const m = text.match(re);
+                        if (m) return m[1];
+                    } catch {}
+                }
+            } catch {}
+            return null;
+        }`) || LISTS_QUERY_ID;
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(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 lists. queryId may have expired.`);
         }
-        return results.slice(0, kwargs.limit);
-    }
+        const seen = new Set();
+        const lists = parseListsManagement(data, seen);
+        return lists.slice(0, limit);
+    },
 });

package/clis/twitter/lists.test.js

@@ -1,50 +1,117 @@
 import { describe, expect, it } from 'vitest';
-import { isEmptyListsState, parseListCards } from './lists-parser.js';
+import { extractListEntry, parseListsManagement } from './lists.js';
 
 describe('twitter lists parser', () => {
-    it('parses english list cards without relying on page locale', () => {
-        const result = parseListCards([
-            {
-                href: '/i/lists/123',
-                text: `AI Researchers
-@jack
-124 Members 3.4K Followers
-Private`,
+    it('extracts a list entry with full metadata', () => {
+        const entry = {
+            content: {
+                itemContent: {
+                    list: {
+                        id_str: '1597593475389984769',
+                        name: 'Crypto',
+                        member_count: 44,
+                        subscriber_count: 8747,
+                        mode: 'Public',
+                    },
+                },
             },
-        ]);
-        expect(result).toEqual([
-            {
-                name: 'AI Researchers',
-                members: '124',
-                followers: '3.4K',
-                mode: 'private',
-            },
-        ]);
+        };
+        expect(extractListEntry(entry, new Set())).toEqual({
+            id: '1597593475389984769',
+            name: 'Crypto',
+            members: '44',
+            followers: '8747',
+            mode: 'public',
+        });
     });
 
-    it('parses chinese list cards without scanning document.body.innerText', () => {
-        const result = parseListCards([
-            {
-                href: '/i/lists/456',
-                text: `AI观察
-@jack
-321 位成员 8.8K 位关注者
-锁定列表`,
+    it('maps Private mode to private', () => {
+        const entry = {
+            content: {
+                itemContent: {
+                    list: {
+                        id_str: '2044679538156912976',
+                        name: 'AI & Agents',
+                        member_count: 15,
+                        subscriber_count: 0,
+                        mode: 'Private',
+                    },
+                },
             },
-        ]);
-        expect(result).toEqual([
-            {
-                name: 'AI观察',
-                members: '321',
-                followers: '8.8K',
-                mode: 'private',
+        };
+        expect(extractListEntry(entry, new Set())?.mode).toBe('private');
+    });
+
+    it('deduplicates by list id', () => {
+        const entry = {
+            content: { itemContent: { list: { id_str: '1', name: 'X' } } },
+        };
+        const seen = new Set();
+        expect(extractListEntry(entry, seen)).not.toBeNull();
+        expect(extractListEntry(entry, seen)).toBeNull();
+    });
+
+    it('returns null when no list payload is present', () => {
+        expect(extractListEntry({}, new Set())).toBeNull();
+        expect(extractListEntry({ content: { itemContent: {} } }, new Set())).toBeNull();
+    });
+
+    it('parses ListsManagementPageTimeline payload instructions', () => {
+        const payload = {
+            data: {
+                viewer: {
+                    list_management_timeline: {
+                        timeline: {
+                            instructions: [
+                                {
+                                    entries: [
+                                        {
+                                            entryId: 'owned-list-1',
+                                            content: {
+                                                itemContent: {
+                                                    list: { id_str: '1', name: 'Crypto', member_count: 44, subscriber_count: 8747, mode: 'Public' },
+                                                },
+                                            },
+                                        },
+                                        {
+                                            entryId: 'subscribed-list-2',
+                                            content: {
+                                                itemContent: {
+                                                    list: { id_str: '2', name: 'AI', member_count: 15, subscriber_count: 0, mode: 'Private' },
+                                                },
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                },
             },
-        ]);
+        };
+        const result = parseListsManagement(payload, new Set());
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ id: '1', name: 'Crypto', mode: 'public' });
+        expect(result[1]).toMatchObject({ id: '2', name: 'AI', mode: 'private' });
     });
 
-    it('detects empty state text in english and chinese', () => {
-        expect(isEmptyListsState(`@jack hasn't created any Lists yet`)).toBe(true);
-        expect(isEmptyListsState('这个账号还没有创建任何列表')).toBe(true);
-        expect(isEmptyListsState('AI Researchers 124 Members')).toBe(false);
+    it('returns empty list for malformed payload', () => {
+        expect(parseListsManagement({}, new Set())).toEqual([]);
+        expect(parseListsManagement({ data: {} }, new Set())).toEqual([]);
+    });
+
+    it('dedupes across repeated entries', () => {
+        const entryA = { content: { itemContent: { list: { id_str: '1', name: 'A' } } } };
+        const payload = {
+            data: {
+                viewer: {
+                    list_management_timeline: {
+                        timeline: { instructions: [{ entries: [entryA, entryA] }] },
+                    },
+                },
+            },
+        };
+        const result = parseListsManagement(payload, new Set());
+        expect(result).toHaveLength(1);
     });
 });

package/clis/twitter/shared.js

@@ -5,14 +5,19 @@ export function sanitizeQueryId(resolved, fallbackId) {
 export async function resolveTwitterQueryId(page, operationName, fallbackId) {
     const resolved = await page.evaluate(`async () => {
     const operationName = ${JSON.stringify(operationName)};
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5000);
     try {
-      const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
+      const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json', { signal: controller.signal });
+      clearTimeout(timeout);
       if (ghResp.ok) {
         const data = await ghResp.json();
         const entry = data?.[operationName];
         if (entry && entry.queryId) return entry.queryId;
       }
-    } catch {}
+    } catch {
+      clearTimeout(timeout);
+    }
     try {
       const scripts = performance.getEntriesByType('resource')
         .filter(r => r.name.includes('client-web') && r.name.endsWith('.js'))