@jackwener/opencli 1.7.21 → 1.8.0

package/clis/twitter/search.js

@@ -1,6 +1,6 @@
 import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { extractMedia, normalizeTwitterGraphqlPayload, resolveTwitterOperationMetadata } from './shared.js';
+import { extractMedia, extractCard, extractQuotedTweet, normalizeTwitterGraphqlPayload, resolveTwitterOperationMetadata } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
 // ── Public-search operator surface ─────────────────────────────────────
@@ -212,15 +212,19 @@ function tweetToRow(result, seen) {
     if (!tweet?.rest_id || seen.has(tweet.rest_id)) return null;
     seen.add(tweet.rest_id);
     const tweetUser = tweet.core?.user_results?.result;
+    const bio = tweetUser?.legacy?.description || '';
     return {
         id: tweet.rest_id,
         author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown',
+        bio,
         text: tweet.note_tweet?.note_tweet_results?.result?.text || tweet.legacy?.full_text || '',
         created_at: tweet.legacy?.created_at || '',
         likes: tweet.legacy?.favorite_count || 0,
         views: tweet.views?.count || '0',
         url: `https://x.com/i/status/${tweet.rest_id}`,
         ...extractMedia(tweet.legacy),
+        card: extractCard(tweet),
+        quoted_tweet: extractQuotedTweet(tweet),
     };
 }
 
@@ -271,7 +275,7 @@ cli({
         { name: 'limit', type: 'int', default: 15, help: 'Maximum number of tweets to return (default 15). Result count after server-side filtering.' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the results by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps X\'s native ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'created_at', 'likes', 'views', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'created_at', 'likes', 'views', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const finalQuery = buildSearchQuery(kwargs.query, kwargs);
         if (!finalQuery) {

package/clis/twitter/search.test.js

@@ -44,6 +44,9 @@ describe('twitter search command', () => {
                                                                         core: {
                                                                             screen_name: 'alice',
                                                                         },
+                                                                        legacy: {
+                                                                            description: 'Search author bio',
+                                                                        },
                                                                     },
                                                                 },
                                                             },
@@ -68,6 +71,7 @@ describe('twitter search command', () => {
             {
                 id: '1',
                 author: 'alice',
+                bio: 'Search author bio',
                 text: 'hello world',
                 created_at: 'Thu Mar 26 10:30:00 +0000 2026',
                 likes: 7,
@@ -75,6 +79,8 @@ describe('twitter search command', () => {
                 url: 'https://x.com/i/status/1',
                 has_media: false,
                 media_urls: [],
+                card: null,
+                quoted_tweet: null,
             },
         ]);
         expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });

package/clis/twitter/shared.js

@@ -288,6 +288,148 @@ export function extractMedia(legacy) {
     }
     return { has_media: urls.length > 0, media_urls: urls };
 }
+
+/**
+ * Extract the link-preview card from a tweet's GraphQL response.
+ *
+ * Reads `tweet.card.legacy.{name, binding_values}` plus the expanded URL from
+ * the `tweet.legacy.entities.urls` entry matching the card's t.co URL.
+ * `binding_values` is an array of `{ key, value: { type, string_value, image_value: { url } } }`.
+ *
+ * Returns `null` when:
+ *   - the tweet has no card, OR
+ *   - the card is structurally empty (no landing URL AND no title/description),
+ *     which would be useless to downstream renderers.
+ *
+ * Otherwise returns a partial card object — missing fields are simply omitted
+ * (no `undefined` values in the output) so JSON consumers see a clean shape.
+ */
+export function extractCard(tweet) {
+    const cardLegacy = tweet?.card?.legacy;
+    if (!cardLegacy) return null;
+    const bindings = Array.isArray(cardLegacy.binding_values) ? cardLegacy.binding_values : [];
+    const byKey = new Map();
+    for (const b of bindings) {
+        if (b && typeof b.key === 'string') byKey.set(b.key, b.value);
+    }
+    const str = (key) => {
+        const v = byKey.get(key);
+        return typeof v?.string_value === 'string' && v.string_value.length > 0 ? v.string_value : undefined;
+    };
+    const img = (key) => {
+        const v = byKey.get(key);
+        const u = v?.image_value?.url;
+        return typeof u === 'string' && u.length > 0 ? u : undefined;
+    };
+    const title = str('title');
+    const description = str('description');
+    const domainBinding = str('domain');
+    const cardUrlBinding = str('card_url');
+    const image_url = img('thumbnail_image_large') || img('photo_image_full_size_large') || img('summary_photo_image_large');
+    const urlEntities = Array.isArray(tweet?.legacy?.entities?.urls)
+        ? tweet.legacy.entities.urls
+        : [];
+    const matchingEntity = cardUrlBinding
+        ? urlEntities.find((entity) => entity?.url === cardUrlBinding || entity?.expanded_url === cardUrlBinding)
+        : undefined;
+    const matchedExpandedUrl = matchingEntity?.expanded_url;
+    const url = (typeof matchedExpandedUrl === 'string' && matchedExpandedUrl.length > 0)
+        ? matchedExpandedUrl
+        : cardUrlBinding;
+    let domain = domainBinding;
+    if (!domain && url) {
+        try { domain = new URL(url).hostname; }
+        catch { /* malformed url — domain stays undefined */ }
+    }
+    if (!url && !title && !description) return null;
+    const out = { name: cardLegacy.name };
+    if (title) out.title = title;
+    if (description) out.description = description;
+    if (image_url) out.image_url = image_url;
+    if (url) out.url = url;
+    if (domain) out.domain = domain;
+    return out;
+}
+
+/**
+ * Extract the quoted tweet from a tweet's GraphQL response.
+ *
+ * A quote tweet is a tweet that embeds and comments on another tweet (distinct
+ * from a reply or retweet). The author writes new commentary and the embedded
+ * tweet renders as a card-like preview under the new tweet.
+ *
+ * GraphQL surfaces this as `tweet.quoted_status_result.result`, which contains
+ * the same `legacy / core / card / note_tweet` shape as the outer tweet — so
+ * we reuse `extractMedia` / `extractCard` on the nested object. Detection is
+ * gated by `legacy.is_quote_status === true` (plus the presence of the nested
+ * result) so we don't return junk on plain replies that share field shapes.
+ *
+ * Returns `null` when:
+ *   - the tweet is not a quote, OR
+ *   - the nested `quoted_status_result.result` is missing/empty/tombstoned.
+ *
+ * Only goes ONE level deep — a quote-of-a-quote returns its level-1 quoted
+ * tweet without further nesting. Recursing would explode payload size on
+ * threads where every reply re-quotes the original.
+ *
+ * The output shape is a deliberately small subset of the main tweet shape
+ * (id/author/name/text/created_at/url + media + card). Consumers that need
+ * counts or full author bio of the quoted tweet can re-fetch the quoted id
+ * via `twitter thread <id>` — keeping this slim avoids ballooning every
+ * timeline/list/search response by 2-3x.
+ */
+export function extractQuotedTweet(tweet) {
+    const legacy = tweet?.legacy;
+    if (!legacy?.is_quote_status) return null;
+    const q = tweet?.quoted_status_result?.result
+        ?? tweet?.legacy?.quoted_status_result?.result;
+    // `result` can be a tombstone (`__typename: 'TweetTombstone'`) or
+    // `'TweetUnavailable'` when the quoted tweet was deleted / privacy-restricted.
+    if (!q) return null;
+    // Nested `tweet` wrapper appears on TweetWithVisibilityResults — same
+    // shim that callers already do at the top level (`tw.tweet || tw`).
+    const qTw = q.tweet || q;
+    if (!qTw || typeof qTw !== 'object') return null;
+    const qLegacy = qTw.legacy && typeof qTw.legacy === 'object' ? qTw.legacy : {};
+    // `rest_id` is required — tombstoned / unavailable wrappers have neither
+    // rest_id nor legacy. Don't fall back to outer `legacy.quoted_status_id_str`:
+    // the id alone can't substitute for missing content (author/text/media all
+    // empty), so emitting a stub object would mislead downstream renderers into
+    // drawing an empty "quoted tweet" preview.
+    if (typeof qTw.rest_id !== 'string' || !qTw.rest_id.trim()) return null;
+    const qUser = qTw.core?.user_results?.result;
+    const qLegacyScreenName = qUser?.legacy?.screen_name;
+    const qCoreScreenName = qUser?.core?.screen_name;
+    const qScreenName = typeof qLegacyScreenName === 'string' && qLegacyScreenName.trim()
+        ? qLegacyScreenName.trim()
+        : (typeof qCoreScreenName === 'string' && qCoreScreenName.trim() ? qCoreScreenName.trim() : '');
+    if (!SCREEN_NAME_PATTERN.test(qScreenName)) return null;
+    const qLegacyDisplayName = qUser?.legacy?.name;
+    const qCoreDisplayName = qUser?.core?.name;
+    const qDisplayName = typeof qLegacyDisplayName === 'string'
+        ? qLegacyDisplayName
+        : (typeof qCoreDisplayName === 'string' ? qCoreDisplayName : '');
+    const qNoteText = qTw.note_tweet?.note_tweet_results?.result?.text;
+    const qText = (typeof qNoteText === 'string' && qNoteText.length > 0)
+        ? qNoteText
+        : (typeof qLegacy.full_text === 'string' ? qLegacy.full_text : '');
+    const qMedia = extractMedia(qLegacy);
+    const qCard = extractCard(qTw);
+    if (!qText && !qMedia.has_media && !qCard) return null;
+    const out = {
+        id: qTw.rest_id,
+        author: qScreenName,
+        name: qDisplayName,
+        text: qText,
+        created_at: typeof qLegacy.created_at === 'string' ? qLegacy.created_at : '',
+        url: `https://x.com/${qScreenName}/status/${qTw.rest_id}`,
+        has_media: qMedia.has_media,
+        media_urls: qMedia.media_urls,
+    };
+    if (qCard) out.card = qCard;
+    return out;
+}
+
 export const __test__ = {
     sanitizeQueryId,
     sanitizeTwitterOperationMetadata,
@@ -295,6 +437,8 @@ export const __test__ = {
     normalizeTwitterGraphqlPayload,
     normalizeTwitterScreenName,
     extractMedia,
+    extractCard,
+    extractQuotedTweet,
     parseTweetUrl,
     buildTwitterArticleScopeSource,
 };

package/clis/twitter/shared.test.js

@@ -3,7 +3,27 @@ import { JSDOM } from 'jsdom';
 import { __test__ } from './shared.js';
 import { ArgumentError } from '@jackwener/opencli/errors';
 
-const { extractMedia, parseTweetUrl, buildTwitterArticleScopeSource, unwrapBrowserResult, normalizeTwitterGraphqlPayload, normalizeTwitterScreenName, sanitizeTwitterOperationMetadata } = __test__;
+const { extractMedia, extractCard, extractQuotedTweet, parseTweetUrl, buildTwitterArticleScopeSource, unwrapBrowserResult, normalizeTwitterGraphqlPayload, normalizeTwitterScreenName, sanitizeTwitterOperationMetadata } = __test__;
+
+function makeCardTweet({ name, bindings, expandedUrl, urls }) {
+    const tweet = {
+        card: { legacy: { name, binding_values: bindings } },
+    };
+    if (urls !== undefined) {
+        tweet.legacy = { entities: { urls } };
+        return tweet;
+    }
+    if (expandedUrl !== undefined) {
+        tweet.legacy = { entities: { urls: [{ expanded_url: expandedUrl }] } };
+    }
+    return tweet;
+}
+function strBinding(key, string_value) {
+    return { key, value: { type: 'STRING', string_value } };
+}
+function imgBinding(key, url) {
+    return { key, value: { type: 'IMAGE', image_value: { url } } };
+}
 
 describe('twitter browser result helpers', () => {
     it('unwraps Browser Bridge exec envelopes', () => {
@@ -328,3 +348,411 @@ describe('twitter extractMedia', () => {
         });
     });
 });
+
+describe('twitter extractCard', () => {
+    it('returns null when tweet has no card', () => {
+        expect(extractCard({})).toBeNull();
+        expect(extractCard(undefined)).toBeNull();
+        expect(extractCard({ legacy: { full_text: 'hi' } })).toBeNull();
+    });
+
+    it('extracts full summary_large_image card with all bindings present', () => {
+        const tweet = makeCardTweet({
+            name: 'summary_large_image',
+            bindings: [
+                strBinding('title', 'jackwener/OpenCLI'),
+                strBinding('description', 'Make Any Website & Tool Your CLI'),
+                strBinding('domain', 'github.com'),
+                strBinding('card_url', 'https://t.co/abc'),
+                imgBinding('thumbnail_image_large', 'https://pbs.twimg.com/card_img/thumb_large.jpg'),
+                imgBinding('photo_image_full_size_large', 'https://pbs.twimg.com/card_img/photo_large.jpg'),
+                imgBinding('summary_photo_image_large', 'https://pbs.twimg.com/card_img/summary_large.jpg'),
+            ],
+            urls: [{ url: 'https://t.co/abc', expanded_url: 'https://github.com/jackwener/OpenCLI' }],
+        });
+        expect(extractCard(tweet)).toEqual({
+            name: 'summary_large_image',
+            title: 'jackwener/OpenCLI',
+            description: 'Make Any Website & Tool Your CLI',
+            image_url: 'https://pbs.twimg.com/card_img/thumb_large.jpg',
+            url: 'https://github.com/jackwener/OpenCLI',
+            domain: 'github.com',
+        });
+    });
+
+    it('picks summary_photo_image_large when higher-priority image keys are missing', () => {
+        const tweet = makeCardTweet({
+            name: 'summary',
+            bindings: [
+                strBinding('title', 'Some article'),
+                strBinding('description', 'Body text'),
+                strBinding('domain', 'example.com'),
+                imgBinding('summary_photo_image_large', 'https://pbs.twimg.com/card_img/fallback.jpg'),
+            ],
+            expandedUrl: 'https://example.com/article',
+        });
+        const card = extractCard(tweet);
+        expect(card.image_url).toBe('https://pbs.twimg.com/card_img/fallback.jpg');
+        expect(card.name).toBe('summary');
+    });
+
+    it('derives domain from expanded_url when domain binding is missing', () => {
+        const tweet = makeCardTweet({
+            name: 'promo_image_convo',
+            bindings: [
+                strBinding('title', 'YouTube video'),
+                strBinding('card_url', 'https://t.co/youtube'),
+                imgBinding('photo_image_full_size_large', 'https://pbs.twimg.com/card_img/yt.jpg'),
+            ],
+            urls: [{ url: 'https://t.co/youtube', expanded_url: 'https://www.youtube.com/watch?v=abc' }],
+        });
+        const card = extractCard(tweet);
+        expect(card.url).toBe('https://www.youtube.com/watch?v=abc');
+        expect(card.domain).toBe('www.youtube.com');
+        expect(card.image_url).toBe('https://pbs.twimg.com/card_img/yt.jpg');
+    });
+
+    it('falls back to card_url binding when there is no expanded_url', () => {
+        const tweet = makeCardTweet({
+            name: 'summary_large_image',
+            bindings: [
+                strBinding('title', 'arXiv paper'),
+                strBinding('card_url', 'https://arxiv.org/abs/2305.12345'),
+            ],
+            expandedUrl: undefined,
+        });
+        const card = extractCard(tweet);
+        expect(card.url).toBe('https://arxiv.org/abs/2305.12345');
+        expect(card.domain).toBe('arxiv.org');
+    });
+
+    it('matches card_url to the correct URL entity instead of assuming the first tweet URL', () => {
+        const tweet = makeCardTweet({
+            name: 'summary_large_image',
+            bindings: [
+                strBinding('title', 'OpenCLI release'),
+                strBinding('card_url', 'https://t.co/card123'),
+            ],
+            urls: [
+                { url: 'https://t.co/unrelated', expanded_url: 'https://example.com/unrelated' },
+                { url: 'https://t.co/card123', expanded_url: 'https://github.com/jackwener/OpenCLI/releases' },
+            ],
+        });
+        const card = extractCard(tweet);
+        expect(card.url).toBe('https://github.com/jackwener/OpenCLI/releases');
+        expect(card.domain).toBe('github.com');
+    });
+
+    it('falls back to card_url itself when no matching URL entity is present', () => {
+        const tweet = makeCardTweet({
+            name: 'summary_large_image',
+            bindings: [
+                strBinding('title', 'Unmatched card'),
+                strBinding('card_url', 'https://t.co/card123'),
+            ],
+            urls: [
+                { url: 'https://t.co/unrelated', expanded_url: 'https://example.com/unrelated' },
+            ],
+        });
+        const card = extractCard(tweet);
+        expect(card.url).toBe('https://t.co/card123');
+        expect(card.domain).toBe('t.co');
+    });
+
+    it('omits missing fields rather than emitting undefined values', () => {
+        const tweet = makeCardTweet({
+            name: 'summary',
+            bindings: [
+                strBinding('title', 'Just a title'),
+                strBinding('description', 'Just a description'),
+                strBinding('card_url', 'https://t.co/example'),
+            ],
+            urls: [{ url: 'https://t.co/example', expanded_url: 'https://example.com/x' }],
+        });
+        const card = extractCard(tweet);
+        expect('image_url' in card).toBe(false);
+        expect(card).toEqual({
+            name: 'summary',
+            title: 'Just a title',
+            description: 'Just a description',
+            url: 'https://example.com/x',
+            domain: 'example.com',
+        });
+    });
+
+    it('returns null for a structurally empty card (no url, no title, no description)', () => {
+        const tweet = makeCardTweet({
+            name: 'summary',
+            bindings: [
+                imgBinding('thumbnail_image_large', 'https://pbs.twimg.com/card_img/x.jpg'),
+            ],
+            expandedUrl: undefined,
+        });
+        expect(extractCard(tweet)).toBeNull();
+    });
+
+    it('does not throw on a malformed expanded_url; domain is simply omitted', () => {
+        const tweet = makeCardTweet({
+            name: 'summary',
+            bindings: [
+                strBinding('title', 'broken url card'),
+                strBinding('card_url', 'https://t.co/broken'),
+            ],
+            urls: [{ url: 'https://t.co/broken', expanded_url: 'not a url' }],
+        });
+        const card = extractCard(tweet);
+        expect(card.url).toBe('not a url');
+        expect('domain' in card).toBe(false);
+    });
+
+    it('tolerates missing binding_values array', () => {
+        const tweet = {
+            card: { legacy: { name: 'summary' } },
+            legacy: { entities: { urls: [{ expanded_url: 'https://example.com/' }] } },
+        };
+        const card = extractCard(tweet);
+        expect(card).toBeNull();
+    });
+});
+
+describe('twitter extractQuotedTweet', () => {
+    it('returns null on plain tweets (is_quote_status absent or false)', () => {
+        expect(extractQuotedTweet({})).toBeNull();
+        expect(extractQuotedTweet({ legacy: {} })).toBeNull();
+        expect(extractQuotedTweet({ legacy: { is_quote_status: false } })).toBeNull();
+        // is_quote_status true but no nested result (deleted / restricted): still null
+        expect(extractQuotedTweet({
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+        })).toBeNull();
+    });
+
+    it('returns null on tombstoned / unavailable quoted tweets', () => {
+        // GraphQL emits TweetTombstone / TweetUnavailable when the quoted tweet
+        // is deleted, suspended, or privacy-restricted. The wrapper has no
+        // `legacy` / `rest_id` — null-coalesces in the helper cover this.
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+            quoted_status_result: { result: { __typename: 'TweetTombstone' } },
+        };
+        expect(extractQuotedTweet(tweet)).toBeNull();
+    });
+
+    it('returns null when the quoted tweet lacks author identity', () => {
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+            quoted_status_result: {
+                result: {
+                    rest_id: '99',
+                    legacy: { full_text: 'real quoted text' },
+                    core: { user_results: { result: { legacy: {} } } },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)).toBeNull();
+    });
+
+    it('returns null when the quoted tweet author identity has the wrong shape', () => {
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+            quoted_status_result: {
+                result: {
+                    rest_id: '99',
+                    legacy: { full_text: 'real quoted text' },
+                    core: {
+                        user_results: {
+                            result: {
+                                legacy: { screen_name: { value: 'alice' }, name: { value: 'Alice' } },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)).toBeNull();
+    });
+
+    it('returns null when the quoted tweet author handle is not a valid screen name', () => {
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+            quoted_status_result: {
+                result: {
+                    rest_id: '99',
+                    legacy: { full_text: 'real quoted text' },
+                    core: { user_results: { result: { legacy: { screen_name: 'not/a/user' } } } },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)).toBeNull();
+    });
+
+    it('returns null when the quoted tweet lacks renderable content', () => {
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '99' },
+            quoted_status_result: {
+                result: {
+                    rest_id: '99',
+                    legacy: {},
+                    core: { user_results: { result: { legacy: { screen_name: 'alice' } } } },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)).toBeNull();
+    });
+
+    it('extracts a minimal quoted tweet shape with author, text, url', () => {
+        const tweet = {
+            legacy: { is_quote_status: true, quoted_status_id_str: '2040254679301718161' },
+            quoted_status_result: {
+                result: {
+                    rest_id: '2040254679301718161',
+                    legacy: {
+                        full_text: '罗某官二代背景考',
+                        created_at: 'Wed May 13 22:00:00 +0000 2026',
+                    },
+                    core: {
+                        user_results: {
+                            result: { legacy: { screen_name: 'alice', name: 'Alice' } },
+                        },
+                    },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)).toEqual({
+            id: '2040254679301718161',
+            author: 'alice',
+            name: 'Alice',
+            text: '罗某官二代背景考',
+            created_at: 'Wed May 13 22:00:00 +0000 2026',
+            url: 'https://x.com/alice/status/2040254679301718161',
+            has_media: false,
+            media_urls: [],
+        });
+    });
+
+    it('extracts media from the quoted tweet via extractMedia', () => {
+        const tweet = {
+            legacy: { is_quote_status: true },
+            quoted_status_result: {
+                result: {
+                    rest_id: '99',
+                    legacy: {
+                        full_text: '日本电车实录',
+                        extended_entities: {
+                            media: [
+                                { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/a.jpg' },
+                                { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/b.jpg' },
+                            ],
+                        },
+                    },
+                    core: { user_results: { result: { legacy: { screen_name: 'rwayne' } } } },
+                },
+            },
+        };
+        const q = extractQuotedTweet(tweet);
+        expect(q.has_media).toBe(true);
+        expect(q.media_urls).toEqual([
+            'https://pbs.twimg.com/media/a.jpg',
+            'https://pbs.twimg.com/media/b.jpg',
+        ]);
+    });
+
+    it('extracts the quoted tweet card when present', () => {
+        const tweet = {
+            legacy: { is_quote_status: true },
+            quoted_status_result: {
+                result: {
+                    rest_id: '100',
+                    legacy: {
+                        full_text: '',
+                        entities: {
+                            urls: [{ url: 'https://t.co/abc', expanded_url: 'https://github.com/x/y' }],
+                        },
+                    },
+                    core: { user_results: { result: { legacy: { screen_name: 'bob' } } } },
+                    card: {
+                        legacy: {
+                            name: 'summary_large_image',
+                            binding_values: [
+                                { key: 'title', value: { type: 'STRING', string_value: 'x/y' } },
+                                { key: 'card_url', value: { type: 'STRING', string_value: 'https://t.co/abc' } },
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const q = extractQuotedTweet(tweet);
+        expect(q.card).toEqual({
+            name: 'summary_large_image',
+            title: 'x/y',
+            url: 'https://github.com/x/y',
+            domain: 'github.com',
+        });
+    });
+
+    it('prefers long-form note_tweet text over truncated legacy full_text', () => {
+        const tweet = {
+            legacy: { is_quote_status: true },
+            quoted_status_result: {
+                result: {
+                    rest_id: '101',
+                    legacy: { full_text: 'short…' },
+                    note_tweet: { note_tweet_results: { result: { text: 'full long body of the quoted tweet' } } },
+                    core: { user_results: { result: { legacy: { screen_name: 'carol' } } } },
+                },
+            },
+        };
+        expect(extractQuotedTweet(tweet)?.text).toBe('full long body of the quoted tweet');
+    });
+
+    it('unwraps TweetWithVisibilityResults — quoted_status_result.result.tweet shim', () => {
+        // Mirrors the top-level `tw.tweet || tw` shim that callers do for sensitive content.
+        const tweet = {
+            legacy: { is_quote_status: true },
+            quoted_status_result: {
+                result: {
+                    __typename: 'TweetWithVisibilityResults',
+                    tweet: {
+                        rest_id: '102',
+                        legacy: { full_text: 'sensitive content quoted' },
+                        core: { user_results: { result: { legacy: { screen_name: 'dave' } } } },
+                    },
+                },
+            },
+        };
+        const q = extractQuotedTweet(tweet);
+        expect(q?.id).toBe('102');
+        expect(q?.author).toBe('dave');
+        expect(q?.text).toBe('sensitive content quoted');
+    });
+
+    it('does NOT recurse — a quote of a quote drops the inner-inner quote', () => {
+        // Avoid payload explosion on threads where every reply re-quotes the root.
+        // Level-1 quote is preserved; level-2 (a quote inside the quoted tweet)
+        // is intentionally not surfaced.
+        const tweet = {
+            legacy: { is_quote_status: true },
+            quoted_status_result: {
+                result: {
+                    rest_id: '200',
+                    legacy: {
+                        full_text: 'level-1 quote text',
+                        is_quote_status: true,
+                    },
+                    core: { user_results: { result: { legacy: { screen_name: 'l1' } } } },
+                    quoted_status_result: {
+                        result: {
+                            rest_id: '300',
+                            legacy: { full_text: 'level-2 should be dropped' },
+                            core: { user_results: { result: { legacy: { screen_name: 'l2' } } } },
+                        },
+                    },
+                },
+            },
+        };
+        const q = extractQuotedTweet(tweet);
+        expect(q?.id).toBe('200');
+        expect(q?.text).toBe('level-1 quote text');
+        expect(q).not.toHaveProperty('quoted_tweet');
+    });
+});