@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/clis/twitter/search.test.js

@@ -0,0 +1,236 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+describe('twitter search command', () => {
+    it('retries transient SPA navigation failures before giving up', async () => {
+        const command = getRegistry().get('twitter/search');
+        expect(command?.func).toBeTypeOf('function');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce('/explore')
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce('/search');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([
+                {
+                    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',
+                                                                                },
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                    views: {
+                                                                        count: '12',
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            ]),
+        };
+        const result = await command.func(page, { query: 'from:alice', filter: 'top', limit: 5 });
+        expect(result).toEqual([
+            {
+                id: '1',
+                author: 'alice',
+                text: 'hello world',
+                created_at: 'Thu Mar 26 10:30:00 +0000 2026',
+                likes: 7,
+                views: '12',
+                url: 'https://x.com/i/status/1',
+            },
+        ]);
+        expect(page.installInterceptor).toHaveBeenCalledWith('SearchTimeline');
+        expect(evaluate).toHaveBeenCalledTimes(4);
+    });
+    it('uses f=live in search URL when filter is live', async () => {
+        const command = getRegistry().get('twitter/search');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce('/search');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        };
+        await command.func(page, { query: 'breaking news', filter: 'live', limit: 5 });
+        const pushStateCall = evaluate.mock.calls[0][0];
+        expect(pushStateCall).toContain('f=live');
+        expect(pushStateCall).toContain(encodeURIComponent('breaking news'));
+    });
+    it('uses f=top in search URL when filter is top', async () => {
+        const command = getRegistry().get('twitter/search');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce('/search');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        };
+        await command.func(page, { query: 'test', filter: 'top', limit: 5 });
+        const pushStateCall = evaluate.mock.calls[0][0];
+        expect(pushStateCall).toContain('f=top');
+    });
+    it('falls back to top when filter is omitted', async () => {
+        const command = getRegistry().get('twitter/search');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined)
+            .mockResolvedValueOnce('/search');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        };
+        await command.func(page, { query: 'test', limit: 5 });
+        const pushStateCall = evaluate.mock.calls[0][0];
+        expect(pushStateCall).toContain('f=top');
+    });
+    it('falls back to search input when pushState fails twice', async () => {
+        const command = getRegistry().get('twitter/search');
+        expect(command?.func).toBeTypeOf('function');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined) // pushState attempt 1
+            .mockResolvedValueOnce('/explore') // pathname check 1 — not /search
+            .mockResolvedValueOnce(undefined) // pushState attempt 2
+            .mockResolvedValueOnce('/explore') // pathname check 2 — still not /search
+            .mockResolvedValueOnce({ ok: true }) // search input fallback succeeds
+            .mockResolvedValueOnce('/search'); // pathname check after fallback
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([
+                {
+                    data: {
+                        search_by_raw_query: {
+                            search_timeline: {
+                                timeline: {
+                                    instructions: [
+                                        {
+                                            type: 'TimelineAddEntries',
+                                            entries: [
+                                                {
+                                                    entryId: 'tweet-99',
+                                                    content: {
+                                                        itemContent: {
+                                                            tweet_results: {
+                                                                result: {
+                                                                    rest_id: '99',
+                                                                    legacy: {
+                                                                        full_text: 'fallback works',
+                                                                        favorite_count: 3,
+                                                                        created_at: 'Wed Apr 02 12:00:00 +0000 2026',
+                                                                    },
+                                                                    core: {
+                                                                        user_results: {
+                                                                            result: {
+                                                                                core: { screen_name: 'bob' },
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                    views: { count: '5' },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            ]),
+        };
+        const result = await command.func(page, { query: 'test fallback', filter: 'top', limit: 5 });
+        expect(result).toEqual([
+            {
+                id: '99',
+                author: 'bob',
+                text: 'fallback works',
+                created_at: 'Wed Apr 02 12:00:00 +0000 2026',
+                likes: 3,
+                views: '5',
+                url: 'https://x.com/i/status/99',
+            },
+        ]);
+        // 6 evaluate calls: 2x pushState + 2x pathname check + 1x fallback + 1x pathname check
+        expect(evaluate).toHaveBeenCalledTimes(6);
+        expect(page.autoScroll).toHaveBeenCalled();
+    });
+    it('throws with the final path after both attempts fail', async () => {
+        const command = getRegistry().get('twitter/search');
+        expect(command?.func).toBeTypeOf('function');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined) // pushState attempt 1
+            .mockResolvedValueOnce('/explore') // pathname check 1
+            .mockResolvedValueOnce(undefined) // pushState attempt 2
+            .mockResolvedValueOnce('/login') // pathname check 2
+            .mockResolvedValueOnce({ ok: false }); // search input fallback
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn(),
+        };
+        await expect(command.func(page, { query: 'from:alice', filter: 'top', limit: 5 }))
+            .rejects
+            .toThrow('Final path: /login');
+        expect(page.autoScroll).not.toHaveBeenCalled();
+        expect(page.getInterceptedRequests).not.toHaveBeenCalled();
+        expect(evaluate).toHaveBeenCalledTimes(5);
+    });
+});

package/vendor/opencli/dist/clis/twitter/shared.d.ts

@@ -0,0 +1,6 @@
+import type { IPage } from '../../types.js';
+export declare function sanitizeQueryId(resolved: unknown, fallbackId: string): string;
+export declare function resolveTwitterQueryId(page: Pick<IPage, 'evaluate'>, operationName: string, fallbackId: string): Promise<string>;
+export declare const __test__: {
+    sanitizeQueryId: typeof sanitizeQueryId;
+};

package/vendor/opencli/dist/clis/twitter/shared.js

@@ -0,0 +1,35 @@
+const QUERY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+export function sanitizeQueryId(resolved, fallbackId) {
+    return typeof resolved === 'string' && QUERY_ID_PATTERN.test(resolved) ? resolved : fallbackId;
+}
+export async function resolveTwitterQueryId(page, operationName, fallbackId) {
+    const resolved = await page.evaluate(`async () => {
+    const operationName = ${JSON.stringify(operationName)};
+    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?.[operationName];
+        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 = new RegExp('queryId:"([A-Za-z0-9_-]+)"[^}]{0,200}operationName:"' + operationName + '"');
+          const match = text.match(re);
+          if (match) return match[1];
+        } catch {}
+      }
+    } catch {}
+    return null;
+  }`);
+    return sanitizeQueryId(resolved, fallbackId);
+}
+export const __test__ = {
+    sanitizeQueryId,
+};

package/vendor/opencli/dist/clis/twitter/thread.d.ts

@@ -0,0 +1 @@
+export {};

package/vendor/opencli/dist/clis/twitter/thread.js

@@ -0,0 +1,151 @@
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+// ── Twitter GraphQL constants ──────────────────────────────────────────
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const TWEET_DETAIL_QUERY_ID = 'nBS-WpgA6ZG0CyNHD517JQ';
+const FEATURES = {
+    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,
+    longform_notetweets_consumption_enabled: true,
+    longform_notetweets_rich_text_read_enabled: true,
+    longform_notetweets_inline_media_enabled: true,
+    freedom_of_speech_not_reach_fetch_enabled: true,
+};
+const FIELD_TOGGLES = { withArticleRichContentState: true, withArticlePlainText: false };
+function buildTweetDetailUrl(tweetId, cursor) {
+    const vars = {
+        focalTweetId: tweetId,
+        referrer: 'tweet',
+        with_rux_injections: false,
+        includePromotedContent: false,
+        rankingMode: 'Recency',
+        withCommunity: true,
+        withQuickPromoteEligibilityTweetFields: true,
+        withBirdwatchNotes: true,
+        withVoice: true,
+    };
+    if (cursor)
+        vars.cursor = cursor;
+    return `/i/api/graphql/${TWEET_DETAIL_QUERY_ID}/TweetDetail`
+        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`
+        + `&fieldToggles=${encodeURIComponent(JSON.stringify(FIELD_TOGGLES))}`;
+}
+function extractTweet(r, seen) {
+    if (!r)
+        return null;
+    const tw = r.tweet || r;
+    const l = tw.legacy || {};
+    if (!tw.rest_id || seen.has(tw.rest_id))
+        return null;
+    seen.add(tw.rest_id);
+    const u = tw.core?.user_results?.result;
+    const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+    const screenName = u?.legacy?.screen_name || u?.core?.screen_name || 'unknown';
+    return {
+        id: tw.rest_id,
+        author: screenName,
+        text: noteText || l.full_text || '',
+        likes: l.favorite_count || 0,
+        retweets: l.retweet_count || 0,
+        in_reply_to: l.in_reply_to_status_id_str || undefined,
+        created_at: l.created_at,
+        url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+    };
+}
+function parseTweetDetail(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    const instructions = data?.data?.threaded_conversation_with_injections_v2?.instructions
+        || data?.data?.tweetResult?.result?.timeline?.instructions
+        || [];
+    for (const inst of instructions) {
+        for (const entry of inst.entries || []) {
+            // Cursor entries
+            const c = entry.content;
+            if (c?.entryType === 'TimelineTimelineCursor' || c?.__typename === 'TimelineTimelineCursor') {
+                if (c.cursorType === 'Bottom' || c.cursorType === 'ShowMore')
+                    nextCursor = c.value;
+                continue;
+            }
+            if (entry.entryId?.startsWith('cursor-bottom-') || entry.entryId?.startsWith('cursor-showMore-')) {
+                nextCursor = c?.itemContent?.value || c?.value || nextCursor;
+                continue;
+            }
+            // Direct tweet entry
+            const tw = extractTweet(c?.itemContent?.tweet_results?.result, seen);
+            if (tw)
+                tweets.push(tw);
+            // Conversation module (nested replies)
+            for (const item of c?.items || []) {
+                const nested = extractTweet(item.item?.itemContent?.tweet_results?.result, seen);
+                if (nested)
+                    tweets.push(nested);
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+// ── CLI definition ────────────────────────────────────────────────────
+cli({
+    site: 'twitter',
+    name: 'thread',
+    description: 'Get a tweet thread (original + all replies)',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'tweet-id', positional: true, type: 'string', required: true },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url'],
+    func: async (page, kwargs) => {
+        let tweetId = kwargs['tweet-id'];
+        const urlMatch = tweetId.match(/\/status\/(\d+)/);
+        if (urlMatch)
+            tweetId = urlMatch[1];
+        // Navigate to x.com for cookie context
+        await page.goto('https://x.com');
+        await page.wait(3);
+        // Extract CSRF token — the only thing we need from the browser
+        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)');
+        // Build auth headers in TypeScript
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+        // Paginate — fetch in browser, parse in TypeScript
+        const allTweets = [];
+        const seen = new Set();
+        let cursor = null;
+        for (let i = 0; i < 5; i++) {
+            const apiUrl = buildTweetDetailUrl(tweetId, cursor);
+            // Browser-side: just fetch + return JSON (3 lines)
+            const data = await page.evaluate(`async () => {
+        const r = await fetch("${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}: Tweet not found or queryId expired`);
+                break;
+            }
+            // TypeScript-side: type-safe parsing + cursor extraction
+            const { tweets, nextCursor } = parseTweetDetail(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        return allTweets.slice(0, kwargs.limit);
+    },
+});

package/vendor/opencli/dist/clis/twitter/timeline.d.ts

@@ -0,0 +1,24 @@
+type TimelineType = 'for-you' | 'following';
+interface TimelineTweet {
+    id: string;
+    author: string;
+    text: string;
+    likes: number;
+    retweets: number;
+    replies: number;
+    views: number;
+    created_at: string;
+    url: string;
+}
+declare function buildTimelineVariables(type: TimelineType, count: number, cursor?: string | null): Record<string, unknown>;
+declare function buildHomeTimelineUrl(queryId: string, endpoint: string, vars: Record<string, unknown>): string;
+declare function parseHomeTimeline(data: any, seen: Set<string>): {
+    tweets: TimelineTweet[];
+    nextCursor: string | null;
+};
+export declare const __test__: {
+    buildTimelineVariables: typeof buildTimelineVariables;
+    buildHomeTimelineUrl: typeof buildHomeTimelineUrl;
+    parseHomeTimeline: typeof parseHomeTimeline;
+};
+export {};

package/vendor/opencli/dist/clis/twitter/timeline.js

@@ -0,0 +1,204 @@
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { resolveTwitterQueryId } from './shared.js';
+// ── Twitter GraphQL constants ──────────────────────────────────────────
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
+const HOME_LATEST_TIMELINE_QUERY_ID = 'BKB7oi212Fi7kQtCBGE4zA';
+// Endpoint config: for-you uses GET HomeTimeline, following uses POST HomeLatestTimeline
+const TIMELINE_ENDPOINTS = {
+    'for-you': { endpoint: 'HomeTimeline', method: 'GET', fallbackQueryId: HOME_TIMELINE_QUERY_ID },
+    following: { endpoint: 'HomeLatestTimeline', method: 'POST', fallbackQueryId: HOME_LATEST_TIMELINE_QUERY_ID },
+};
+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 buildTimelineVariables(type, count, cursor) {
+    const vars = {
+        count,
+        includePromotedContent: false,
+        latestControlAvailable: true,
+        requestContext: 'launch',
+    };
+    if (type === 'for-you')
+        vars.withCommunity = true;
+    if (type === 'following')
+        vars.seenTweetIds = [];
+    if (cursor)
+        vars.cursor = cursor;
+    return vars;
+}
+function buildHomeTimelineUrl(queryId, endpoint, vars) {
+    return (`/i/api/graphql/${queryId}/${endpoint}` +
+        `?variables=${encodeURIComponent(JSON.stringify(vars))}` +
+        `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`);
+}
+function extractTweet(result, seen) {
+    if (!result)
+        return null;
+    const tw = result.tweet || result;
+    const l = tw.legacy || {};
+    if (!tw.rest_id || seen.has(tw.rest_id))
+        return null;
+    seen.add(tw.rest_id);
+    const u = tw.core?.user_results?.result;
+    const screenName = u?.legacy?.screen_name || u?.core?.screen_name || 'unknown';
+    const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
+    const views = tw.views?.count ? parseInt(tw.views.count, 10) : 0;
+    return {
+        id: tw.rest_id,
+        author: screenName,
+        text: noteText || l.full_text || '',
+        likes: l.favorite_count || 0,
+        retweets: l.retweet_count || 0,
+        replies: l.reply_count || 0,
+        views,
+        created_at: l.created_at || '',
+        url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+    };
+}
+function parseHomeTimeline(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    // Both HomeTimeline and HomeLatestTimeline share the same response envelope
+    const instructions = data?.data?.home?.home_timeline_urt?.instructions || [];
+    for (const inst of instructions) {
+        for (const entry of inst.entries || []) {
+            const c = entry.content;
+            // Cursor entries
+            if (c?.entryType === 'TimelineTimelineCursor' || c?.__typename === 'TimelineTimelineCursor') {
+                if (c.cursorType === 'Bottom')
+                    nextCursor = c.value;
+                continue;
+            }
+            if (entry.entryId?.startsWith('cursor-bottom-')) {
+                nextCursor = c?.value || nextCursor;
+                continue;
+            }
+            // Single tweet entry
+            const tweetResult = c?.itemContent?.tweet_results?.result;
+            if (tweetResult) {
+                // Skip promoted content
+                if (c?.itemContent?.promotedMetadata)
+                    continue;
+                const tw = extractTweet(tweetResult, seen);
+                if (tw)
+                    tweets.push(tw);
+                continue;
+            }
+            // Conversation module (grouped tweets)
+            for (const item of c?.items || []) {
+                const nested = item.item?.itemContent?.tweet_results?.result;
+                if (nested) {
+                    if (item.item?.itemContent?.promotedMetadata)
+                        continue;
+                    const tw = extractTweet(nested, seen);
+                    if (tw)
+                        tweets.push(tw);
+                }
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+// ── CLI definition ────────────────────────────────────────────────────
+cli({
+    site: 'twitter',
+    name: 'timeline',
+    description: 'Fetch Twitter timeline (for-you or following)',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        {
+            name: 'type',
+            default: 'for-you',
+            choices: ['for-you', 'following'],
+            help: 'Timeline type: for-you (algorithmic) or following (chronological)',
+        },
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url'],
+    func: async (page, kwargs) => {
+        const limit = kwargs.limit || 20;
+        const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';
+        const { endpoint, method, fallbackQueryId } = TIMELINE_ENDPOINTS[timelineType];
+        // Navigate to x.com for cookie context
+        await page.goto('https://x.com');
+        await page.wait(3);
+        // Extract CSRF token
+        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)');
+        // Dynamically resolve queryId for the selected endpoint
+        const queryId = await resolveTwitterQueryId(page, endpoint, fallbackQueryId);
+        // Build auth headers
+        const headers = JSON.stringify({
+            Authorization: `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+        });
+        // Paginate — fetch in browser, parse in TypeScript
+        const allTweets = [];
+        const seen = new Set();
+        let cursor = null;
+        for (let i = 0; i < 5 && allTweets.length < limit; i++) {
+            const fetchCount = Math.min(40, limit - allTweets.length + 5); // over-fetch slightly for promoted filtering
+            const variables = buildTimelineVariables(timelineType, fetchCount, cursor);
+            const apiUrl = buildHomeTimelineUrl(queryId, endpoint, variables);
+            const data = await page.evaluate(`async () => {
+        const r = await fetch("${apiUrl}", { method: "${method}", 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 timeline. queryId may have expired.`);
+                break;
+            }
+            const { tweets, nextCursor } = parseHomeTimeline(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        return allTweets.slice(0, limit);
+    },
+});
+export const __test__ = {
+    buildTimelineVariables,
+    buildHomeTimelineUrl,
+    parseHomeTimeline,
+};

package/vendor/opencli/dist/clis/twitter/timeline.test.d.ts

@@ -0,0 +1 @@
+export {};