@huyuan-ai/cli 1.0.0 → 1.0.1

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

@@ -0,0 +1,102 @@
+import { AuthRequiredError, SelectorError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'followers',
+    description: 'Get accounts following a Twitter/X user',
+    domain: 'x.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'user', positional: true, type: 'string', required: false },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    columns: ['screen_name', 'name', 'bio', 'followers'],
+    func: async (page, kwargs) => {
+        let targetUser = kwargs.user;
+        // If no user is specified, figure out the logged-in user's handle
+        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('/', '');
+        }
+        // 1. Navigate to profile page
+        await page.goto(`https://x.com/${targetUser}`);
+        await page.wait(3);
+        // 2. Install interceptor BEFORE SPA navigation.
+        //    goto() resets JS context, but SPA click preserves it.
+        await page.installInterceptor('Followers');
+        // 3. Click the followers link via SPA navigation (preserves interceptor).
+        //    Twitter uses /verified_followers instead of /followers now.
+        const safeUser = JSON.stringify(targetUser);
+        const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
+        const selectors = [
+            'a[href="/' + target + '/verified_followers"]',
+            'a[href="/' + target + '/followers"]',
+        ];
+        for (const sel of selectors) {
+            const link = document.querySelector(sel);
+            if (link) { link.click(); return true; }
+        }
+        return false;
+    }`);
+        if (!clicked) {
+            throw new SelectorError('Twitter followers link', 'Twitter may have changed the layout.');
+        }
+        await page.waitForCapture(5);
+        // 4. Scroll to trigger pagination API calls
+        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
+        // 5. Retrieve intercepted data
+        const requests = await page.getInterceptedRequests();
+        const requestList = Array.isArray(requests) ? requests : [];
+        if (requestList.length === 0) {
+            return [];
+        }
+        let results = [];
+        for (const req of requestList) {
+            try {
+                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
+                if (!instructions)
+                    continue;
+                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
+                if (!addEntries) {
+                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
+                }
+                if (!addEntries)
+                    continue;
+                for (const entry of addEntries.entries) {
+                    if (!entry.entryId.startsWith('user-'))
+                        continue;
+                    const item = entry.content?.itemContent?.user_results?.result;
+                    if (!item || item.__typename !== 'User')
+                        continue;
+                    const core = item.core || {};
+                    const legacy = item.legacy || {};
+                    results.push({
+                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
+                        name: core.name || legacy.name || 'unknown',
+                        bio: legacy.description || item.profile_bio?.description || '',
+                        followers: legacy.followers_count || legacy.normal_followers_count || 0
+                    });
+                }
+            }
+            catch (e) {
+                // ignore parsing errors for individual payloads
+            }
+        }
+        // Deduplicate by screen_name
+        const unique = new Map();
+        results.forEach(r => unique.set(r.screen_name, r));
+        const deduplicatedResults = Array.from(unique.values());
+        return deduplicatedResults.slice(0, kwargs.limit);
+    }
+});

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

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

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

@@ -0,0 +1,95 @@
+import { AuthRequiredError, SelectorError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'following',
+    description: 'Get accounts a Twitter/X user is following',
+    domain: 'x.com',
+    strategy: Strategy.INTERCEPT,
+    browser: true,
+    args: [
+        { name: 'user', positional: true, type: 'string', required: false },
+        { name: 'limit', type: 'int', default: 50 },
+    ],
+    columns: ['screen_name', 'name', 'bio', 'followers'],
+    func: async (page, kwargs) => {
+        let targetUser = kwargs.user;
+        // If no user is specified, figure out the logged-in user's handle
+        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('/', '');
+        }
+        // 1. Navigate to profile page
+        await page.goto(`https://x.com/${targetUser}`);
+        await page.wait(3);
+        // 2. Install interceptor BEFORE SPA navigation.
+        //    goto() resets JS context, but SPA click preserves it.
+        await page.installInterceptor('Following');
+        // 3. Click the following link via SPA navigation (preserves interceptor)
+        const safeUser = JSON.stringify(targetUser);
+        const clicked = await page.evaluate(`() => {
+        const target = ${safeUser};
+        const link = document.querySelector('a[href="/' + target + '/following"]');
+        if (link) { link.click(); return true; }
+        return false;
+    }`);
+        if (!clicked) {
+            throw new SelectorError('Twitter following link', 'Twitter may have changed the layout.');
+        }
+        await page.waitForCapture(5);
+        // 4. Scroll to trigger pagination API calls
+        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
+        // 5. Retrieve intercepted data
+        const requests = await page.getInterceptedRequests();
+        const requestList = Array.isArray(requests) ? requests : [];
+        if (requestList.length === 0) {
+            return [];
+        }
+        let results = [];
+        for (const req of requestList) {
+            try {
+                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
+                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
+                if (!instructions)
+                    continue;
+                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
+                if (!addEntries) {
+                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
+                }
+                if (!addEntries)
+                    continue;
+                for (const entry of addEntries.entries) {
+                    if (!entry.entryId.startsWith('user-'))
+                        continue;
+                    const item = entry.content?.itemContent?.user_results?.result;
+                    if (!item || item.__typename !== 'User')
+                        continue;
+                    const core = item.core || {};
+                    const legacy = item.legacy || {};
+                    results.push({
+                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
+                        name: core.name || legacy.name || 'unknown',
+                        bio: legacy.description || item.profile_bio?.description || '',
+                        followers: legacy.followers_count || legacy.normal_followers_count || 0
+                    });
+                }
+            }
+            catch (e) {
+                // ignore parsing errors for individual payloads
+            }
+        }
+        // Deduplicate by screen_name
+        const unique = new Map();
+        results.forEach(r => unique.set(r.screen_name, r));
+        const deduplicatedResults = Array.from(unique.values());
+        return deduplicatedResults.slice(0, kwargs.limit);
+    }
+});

package/vendor/opencli/dist/clis/twitter/hide-reply.d.ts

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

package/vendor/opencli/dist/clis/twitter/hide-reply.js

@@ -0,0 +1,67 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'hide-reply',
+    description: 'Hide a reply on your tweet (useful for hiding bot/spam replies)',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the reply tweet to hide' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter hide-reply');
+        await page.goto(kwargs.url);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        const result = await page.evaluate(`(async () => {
+        try {
+            let attempts = 0;
+            let moreMenu = null;
+
+            while (attempts < 20) {
+                moreMenu = document.querySelector('[aria-label="More"]');
+                if (moreMenu) break;
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!moreMenu) {
+                return { ok: false, message: 'Could not find the "More" menu on this tweet. Are you logged in?' };
+            }
+
+            moreMenu.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Look for the "Hide reply" menu item
+            const items = document.querySelectorAll('[role="menuitem"]');
+            let hideItem = null;
+            for (const item of items) {
+                if (item.textContent && item.textContent.includes('Hide reply')) {
+                    hideItem = item;
+                    break;
+                }
+            }
+
+            if (!hideItem) {
+                return { ok: false, message: 'Could not find "Hide reply" option. This may not be a reply on your tweet.' };
+            }
+
+            hideItem.click();
+            await new Promise(r => setTimeout(r, 1500));
+
+            return { ok: true, message: 'Reply successfully hidden.' };
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok)
+            await page.wait(2);
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

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

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

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

@@ -0,0 +1,69 @@
+import { CommandExecutionError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'like',
+    description: 'Like a specific tweet',
+    domain: 'x.com',
+    strategy: Strategy.UI, // Utilizes internal DOM flows for interaction
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to like' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter like');
+        await page.goto(kwargs.url);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' }); // Wait for tweet to load completely
+        const result = await page.evaluate(`(async () => {
+        try {
+            // Poll for the tweet to render
+            let attempts = 0;
+            let likeBtn = null;
+            let unlikeBtn = null;
+            
+            while (attempts < 20) {
+                unlikeBtn = document.querySelector('[data-testid="unlike"]');
+                likeBtn = document.querySelector('[data-testid="like"]');
+                
+                if (unlikeBtn || likeBtn) break;
+                
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            // Check if it's already liked
+            if (unlikeBtn) {
+                return { ok: true, message: 'Tweet is already liked.' };
+            }
+
+            if (!likeBtn) {
+                return { ok: false, message: 'Could not find the Like button on this tweet after waiting 10 seconds. Are you logged in?' };
+            }
+
+            // Click Like
+            likeBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+            
+            // Verify success by checking if the 'unlike' button appeared
+            const verifyBtn = document.querySelector('[data-testid="unlike"]');
+            if (verifyBtn) {
+                return { ok: true, message: 'Tweet successfully liked.' };
+            } else {
+                return { ok: false, message: 'Like action was initiated but UI did not update as expected.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the like network request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

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

@@ -0,0 +1,24 @@
+import { sanitizeQueryId } from './shared.js';
+interface LikedTweet {
+    id: string;
+    author: string;
+    name: string;
+    text: string;
+    likes: number;
+    retweets: number;
+    created_at: string;
+    url: string;
+}
+declare function buildLikesUrl(queryId: string, userId: string, count: number, cursor?: string | null): string;
+declare function buildUserByScreenNameUrl(queryId: string, screenName: string): string;
+declare function parseLikes(data: any, seen: Set<string>): {
+    tweets: LikedTweet[];
+    nextCursor: string | null;
+};
+export declare const __test__: {
+    sanitizeQueryId: typeof sanitizeQueryId;
+    buildLikesUrl: typeof buildLikesUrl;
+    buildUserByScreenNameUrl: typeof buildUserByScreenNameUrl;
+    parseLikes: typeof parseLikes;
+};
+export {};

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

@@ -0,0 +1,217 @@
+import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError, CommandExecutionError } from '../../errors.js';
+import { resolveTwitterQueryId, sanitizeQueryId } from './shared.js';
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const LIKES_QUERY_ID = 'RozQdCp4CilQzrcuU0NY5w';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+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,
+    responsive_web_grok_analyze_button_fetch_trends_enabled: false,
+    responsive_web_grok_analyze_post_followups_enabled: true,
+    responsive_web_jetfuel_frame: true,
+    responsive_web_grok_share_attachment_enabled: true,
+    responsive_web_grok_annotations_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,
+    responsive_web_grok_show_grok_translated_post: false,
+    responsive_web_grok_analysis_button_from_backend: true,
+    post_ctas_fetch_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: false,
+    responsive_web_grok_image_annotation_enabled: true,
+    responsive_web_grok_imagine_annotation_enabled: true,
+    responsive_web_grok_community_note_auto_translation_is_enabled: false,
+    responsive_web_enhance_cards_enabled: false
+};
+function buildLikesUrl(queryId, userId, count, cursor) {
+    const vars = {
+        userId,
+        count,
+        includePromotedContent: false,
+        withClientEventToken: false,
+        withBirdwatchNotes: false,
+        withVoice: true
+    };
+    if (cursor)
+        vars.cursor = cursor;
+    return `/i/api/graphql/${queryId}/Likes`
+        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
+        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+}
+function buildUserByScreenNameUrl(queryId, screenName) {
+    const vars = JSON.stringify({ screen_name: screenName, withSafetyModeUserFields: true });
+    const feats = JSON.stringify({
+        hidden_profile_subscriptions_enabled: true,
+        rweb_tipjar_consumption_enabled: true,
+        responsive_web_graphql_exclude_directive_enabled: true,
+        verified_phone_label_enabled: false,
+        subscriptions_verification_info_is_identity_verified_enabled: true,
+        subscriptions_verification_info_verified_since_enabled: true,
+        highlights_tweets_tab_ui_enabled: true,
+        responsive_web_twitter_article_notes_tab_enabled: true,
+        subscriptions_feature_can_gift_premium: true,
+        creator_subscriptions_tweet_preview_api_enabled: true,
+        responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+        responsive_web_graphql_timeline_navigation_enabled: true,
+    });
+    return `/i/api/graphql/${queryId}/UserByScreenName`
+        + `?variables=${encodeURIComponent(vars)}`
+        + `&features=${encodeURIComponent(feats)}`;
+}
+function extractLikedTweet(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,
+        created_at: legacy.created_at || '',
+        url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+    };
+}
+function parseLikes(data, seen) {
+    const tweets = [];
+    let nextCursor = null;
+    const instructions = data?.data?.user?.result?.timeline_v2?.timeline?.instructions
+        || data?.data?.user?.result?.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 = extractLikedTweet(content?.itemContent?.tweet_results?.result, seen);
+            if (direct) {
+                tweets.push(direct);
+                continue;
+            }
+            for (const item of content?.items || []) {
+                const nested = extractLikedTweet(item.item?.itemContent?.tweet_results?.result, seen);
+                if (nested)
+                    tweets.push(nested);
+            }
+        }
+    }
+    return { tweets, nextCursor };
+}
+cli({
+    site: 'twitter',
+    name: 'likes',
+    description: 'Fetch liked tweets of a Twitter user',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'username', type: 'string', positional: true, help: 'Twitter screen name (without @). Defaults to logged-in user.' },
+        { name: 'limit', type: 'int', default: 20 },
+    ],
+    columns: ['author', 'name', 'text', 'likes', 'url'],
+    func: async (page, kwargs) => {
+        const limit = kwargs.limit || 20;
+        let username = (kwargs.username || '').replace(/^@/, '');
+        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)');
+        // If no username provided, detect the logged-in user
+        if (!username) {
+            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 detect logged-in user. Are you logged in?');
+            username = href.replace('/', '');
+        }
+        const likesQueryId = await resolveTwitterQueryId(page, 'Likes', LIKES_QUERY_ID);
+        const userByScreenNameQueryId = await resolveTwitterQueryId(page, 'UserByScreenName', USER_BY_SCREEN_NAME_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',
+        });
+        // Get userId from screen_name
+        const userId = await page.evaluate(`async () => {
+      const screenName = ${JSON.stringify(username)};
+      const url = ${JSON.stringify(buildUserByScreenNameUrl(userByScreenNameQueryId, username))};
+      const resp = await fetch(url, { headers: ${headers}, credentials: 'include' });
+      if (!resp.ok) return null;
+      const d = await resp.json();
+      return d.data?.user?.result?.rest_id || null;
+    }`);
+        if (!userId) {
+            throw new CommandExecutionError(`Could not find user @${username}`);
+        }
+        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 = buildLikesUrl(likesQueryId, userId, fetchCount, cursor);
+            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}: Failed to fetch likes. queryId may have expired.`);
+                break;
+            }
+            const { tweets, nextCursor } = parseLikes(data, seen);
+            allTweets.push(...tweets);
+            if (!nextCursor || nextCursor === cursor)
+                break;
+            cursor = nextCursor;
+        }
+        return allTweets.slice(0, limit);
+    },
+});
+export const __test__ = {
+    sanitizeQueryId,
+    buildLikesUrl,
+    buildUserByScreenNameUrl,
+    parseLikes,
+};

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

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

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

@@ -0,0 +1,85 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './likes.js';
+describe('twitter likes helpers', () => {
+    it('falls back when queryId contains unsafe characters', () => {
+        expect(__test__.sanitizeQueryId('safe_Query-123', 'fallback')).toBe('safe_Query-123');
+        expect(__test__.sanitizeQueryId('bad"id', 'fallback')).toBe('fallback');
+        expect(__test__.sanitizeQueryId('bad/id', 'fallback')).toBe('fallback');
+        expect(__test__.sanitizeQueryId(null, 'fallback')).toBe('fallback');
+    });
+    it('builds likes url with the provided queryId', () => {
+        const url = __test__.buildLikesUrl('query123', '42', 20, 'cursor-1');
+        expect(url).toContain('/i/api/graphql/query123/Likes');
+        expect(decodeURIComponent(url)).toContain('"userId":"42"');
+        expect(decodeURIComponent(url)).toContain('"cursor":"cursor-1"');
+    });
+    it('parses likes timeline entries and bottom cursor', () => {
+        const payload = {
+            data: {
+                user: {
+                    result: {
+                        timeline_v2: {
+                            timeline: {
+                                instructions: [
+                                    {
+                                        entries: [
+                                            {
+                                                entryId: 'tweet-1',
+                                                content: {
+                                                    itemContent: {
+                                                        tweet_results: {
+                                                            result: {
+                                                                rest_id: '1',
+                                                                legacy: {
+                                                                    full_text: 'liked post',
+                                                                    favorite_count: 7,
+                                                                    retweet_count: 2,
+                                                                    created_at: 'now',
+                                                                },
+                                                                core: {
+                                                                    user_results: {
+                                                                        result: {
+                                                                            legacy: {
+                                                                                screen_name: 'alice',
+                                                                                name: 'Alice',
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                            {
+                                                entryId: 'cursor-bottom-1',
+                                                content: {
+                                                    entryType: 'TimelineTimelineCursor',
+                                                    cursorType: 'Bottom',
+                                                    value: 'cursor-next',
+                                                },
+                                            },
+                                        ],
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        const result = __test__.parseLikes(payload, new Set());
+        expect(result.nextCursor).toBe('cursor-next');
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({
+            id: '1',
+            author: 'alice',
+            name: 'Alice',
+            text: 'liked post',
+            likes: 7,
+            retweets: 2,
+            created_at: 'now',
+            url: 'https://x.com/alice/status/1',
+        });
+    });
+});