@jackwener/opencli 1.7.22 → 1.8.1

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, looksLikePrivateTwitterTimeline } = __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,447 @@ 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');
+    });
+});
+
+describe('looksLikePrivateTwitterTimeline', () => {
+    it('returns true when result.timeline is an empty object', () => {
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { __typename: 'User', timeline: {} } } },
+        })).toBe(true);
+    });
+    it('returns false when timeline.timeline.instructions is present', () => {
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { timeline: { timeline: { instructions: [] } } } } },
+        })).toBe(false);
+    });
+    it('returns false when timeline_v2.timeline.instructions is present', () => {
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { timeline_v2: { timeline: { instructions: [] } } } } },
+        })).toBe(false);
+    });
+    it('returns false when result is missing entirely', () => {
+        expect(looksLikePrivateTwitterTimeline({})).toBe(false);
+        expect(looksLikePrivateTwitterTimeline(null)).toBe(false);
+        expect(looksLikePrivateTwitterTimeline({ data: { user: {} } })).toBe(false);
+    });
+    it('returns false for non-empty malformed timeline objects', () => {
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { timeline: { unexpected: true } } } },
+        })).toBe(false);
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { timeline: { timeline: {} } } } },
+        })).toBe(false);
+    });
+    it('returns true when timeline_v2.timeline is an empty object', () => {
+        expect(looksLikePrivateTwitterTimeline({
+            data: { user: { result: { timeline_v2: { timeline: {} } } } },
+        })).toBe(true);
+    });
+});

package/clis/twitter/thread.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { extractMedia } from './shared.js';
+import { extractMedia, extractCard, extractQuotedTweet } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const TWEET_DETAIL_QUERY_ID = 'nBS-WpgA6ZG0CyNHD517JQ';
@@ -46,9 +46,11 @@ function extractTweet(r, seen) {
     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';
+    const bio = u?.legacy?.description || '';
     return {
         id: tw.rest_id,
         author: screenName,
+        bio,
         text: noteText || l.full_text || '',
         likes: l.favorite_count || 0,
         retweets: l.retweet_count || 0,
@@ -56,6 +58,8 @@ function extractTweet(r, seen) {
         created_at: l.created_at,
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(l),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 function parseTweetDetail(data, seen) {
@@ -91,6 +95,10 @@ function parseTweetDetail(data, seen) {
     }
     return { tweets, nextCursor };
 }
+
+export const __test__ = {
+    parseTweetDetail,
+};
 // ── CLI definition ────────────────────────────────────────────────────
 cli({
     site: 'twitter',
@@ -105,7 +113,7 @@ cli({
         { name: 'limit', type: 'int', default: 50 },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the thread by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the conversation\'s structural ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         let tweetId = kwargs['tweet-id'];
         const urlMatch = tweetId.match(/\/status\/(\d+)/);

package/clis/twitter/thread.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './thread.js';
+
+describe('twitter thread parser', () => {
+    it('extracts author bio from tweet user entity', () => {
+        const command = getRegistry().get('twitter/thread');
+        expect(command?.columns).toEqual(['id', 'author', 'bio', 'text', 'likes', 'retweets', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet']);
+        const result = __test__.parseTweetDetail({
+            data: {
+                threaded_conversation_with_injections_v2: {
+                    instructions: [
+                        {
+                            entries: [
+                                {
+                                    content: {
+                                        itemContent: {
+                                            tweet_results: {
+                                                result: {
+                                                    rest_id: '1',
+                                                    legacy: {
+                                                        full_text: 'thread tweet',
+                                                        favorite_count: 3,
+                                                        retweet_count: 2,
+                                                    },
+                                                    core: {
+                                                        user_results: {
+                                                            result: {
+                                                                legacy: {
+                                                                    screen_name: 'alice',
+                                                                    description: 'Thread author bio',
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            },
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            },
+        }, new Set());
+        expect(result.tweets).toHaveLength(1);
+        expect(result.tweets[0]).toMatchObject({
+            id: '1',
+            author: 'alice',
+            bio: 'Thread author bio',
+            text: 'thread tweet',
+            likes: 3,
+            retweets: 2,
+            url: 'https://x.com/alice/status/1',
+        });
+    });
+});

package/clis/twitter/timeline.js

@@ -1,6 +1,6 @@
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { resolveTwitterQueryId, extractMedia } from './shared.js';
+import { resolveTwitterQueryId, extractMedia, extractCard, extractQuotedTweet } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
@@ -74,11 +74,13 @@ function extractTweet(result, seen) {
     seen.add(tw.rest_id);
     const u = tw.core?.user_results?.result;
     const screenName = u?.legacy?.screen_name || u?.core?.screen_name || 'unknown';
+    const bio = u?.legacy?.description || '';
     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,
+        bio,
         text: noteText || l.full_text || '',
         likes: l.favorite_count || 0,
         retweets: l.retweet_count || 0,
@@ -87,6 +89,8 @@ function extractTweet(result, seen) {
         created_at: l.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(l),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 function parseHomeTimeline(data, seen) {
@@ -152,7 +156,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Maximum number of tweets to return (default 20).' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the timeline 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', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const limit = kwargs.limit || 20;
         const timelineType = kwargs.type === 'following' ? 'following' : 'for-you';

package/clis/twitter/timeline.test.js

@@ -57,6 +57,7 @@ describe('twitter timeline helpers', () => {
                                                                 result: {
                                                                     legacy: {
                                                                         screen_name: 'alice',
+                                                                        description: 'Timeline author bio',
                                                                     },
                                                                 },
                                                             },
@@ -90,6 +91,7 @@ describe('twitter timeline helpers', () => {
         expect(result.tweets[0]).toMatchObject({
             id: '1',
             author: 'alice',
+            bio: 'Timeline author bio',
             text: 'hello',
             likes: 3,
             retweets: 2,

package/clis/twitter/tweets.js

@@ -1,6 +1,6 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { resolveTwitterOperationMetadata, sanitizeQueryId, extractMedia, normalizeTwitterGraphqlPayload, unwrapBrowserResult } from './shared.js';
+import { resolveTwitterOperationMetadata, sanitizeQueryId, extractMedia, extractQuotedTweet, normalizeTwitterGraphqlPayload, unwrapBrowserResult } from './shared.js';
 import { normalizeTwitterScreenName } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
@@ -175,6 +175,7 @@ function extractTweet(result, seen) {
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(legacy),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 
@@ -226,7 +227,7 @@ cli({
         { name: 'limit', type: 'int', default: 20, help: 'Max tweets to return' },
         { name: 'top-by-engagement', type: 'int', default: 0, help: 'When set to N>0, re-rank the tweets by weighted engagement (likes×1 + retweets×3 + replies×2 + bookmarks×5 + log10(views+1)×0.5) and return the top N. Default 0 keeps the chronological ordering.' },
     ],
-    columns: ['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const limit = Math.max(1, Math.min(200, kwargs.limit || 20));
         const rawUsername = String(kwargs.username ?? '').trim();

package/clis/twitter/tweets.test.js

@@ -6,7 +6,7 @@ import { __test__ } from './tweets.js';
 describe('twitter tweets helpers', () => {
     it('registers id and is_retweet in the default columns', () => {
         const cmd = getRegistry().get('twitter/tweets');
-        expect(cmd?.columns).toEqual(['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls']);
+        expect(cmd?.columns).toEqual(['id', 'author', 'created_at', 'is_retweet', 'text', 'likes', 'retweets', 'replies', 'views', 'url', 'has_media', 'media_urls', 'quoted_tweet']);
     });
 
     it('makes the username argument optional so it can default to the logged-in user', () => {