@jackwener/opencli 1.7.22 → 1.8.1

package/clis/twitter/likes.test.js

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
-import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, EmptyResultError } from '@jackwener/opencli/errors';
 import { __test__ } from './likes.js';
 
 function likesPayload() {
@@ -129,6 +129,31 @@ describe('twitter likes helpers', () => {
     });
 });
 
+describe('twitter likes command', () => {
+    it('throws EmptyResultError with privacy message when API returns empty-timeline shape', async () => {
+        const command = getRegistry().get('twitter/likes');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(async () => [{ name: 'ct0', value: 'token' }]),
+            evaluate: vi.fn(async (script) => {
+                const text = String(script);
+                if (text.includes('AppTabBar_Profile_Link')) return { session: 'site:twitter', data: '/viewer' };
+                if (text.includes('operationName')) return null;
+                if (text.includes('/UserByScreenName')) return { session: 'site:twitter', data: '42' };
+                if (text.includes('/Likes')) {
+                    return { session: 'site:twitter', data: { data: { user: { result: { __typename: 'User', timeline: {} } } } } };
+                }
+                throw new Error(`Unexpected evaluate: ${text.slice(0, 80)}`);
+            }),
+        };
+        await expect(command.func(page, { username: 'simonw', limit: 5 }))
+            .rejects.toMatchObject({ hint: expect.stringContaining('Likes are private by default on X') });
+        await expect(command.func(page, { username: 'simonw', limit: 5 }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+    });
+});
+
 describe('twitter likes command', () => {
     it('rejects invalid explicit username before cookies or navigation', async () => {
         const command = getRegistry().get('twitter/likes');

package/clis/twitter/list-add.js

@@ -4,7 +4,7 @@ import { resolveTwitterQueryId } from './shared.js';
 import { parseListsManagement } from './lists.js';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
-const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'IGgvgiOx4QZndDHuD3x9TQ';
 const LISTS_MANAGEMENT_QUERY_ID = '78UbkyXwXBD98IgUWXOy9g';
 // 2026-05 fallback — X rotates queryIds; resolveTwitterQueryId() does live lookup,
 // this constant is just the default if live lookup fails.

package/clis/twitter/list-create.js

@@ -0,0 +1,155 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { unwrapBrowserResult } from './shared.js';
+import { TWITTER_BEARER_TOKEN } from './utils.js';
+
+const CREATE_LIST_QUERY_ID = 'UQRa0jJ9doxGEIQRea1Y0w';
+const NAME_MAX = 25;
+const DESCRIPTION_MAX = 100;
+
+// Minimal feature set as observed in the real CreateList web request payload.
+// Twitter rejects requests with extra/unknown features (DecodeException).
+const FEATURES = {
+    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,
+    responsive_web_graphql_skip_user_profile_image_extensions_enabled: false,
+    responsive_web_graphql_timeline_navigation_enabled: true,
+};
+
+export function parseListCreateArgs(kwargs) {
+    const name = String(kwargs.name || '').trim();
+    const description = String(kwargs.description || '').trim();
+    const modeRaw = String(kwargs.mode || 'public').trim().toLowerCase();
+    if (!name) {
+        throw new ArgumentError('List name is required', 'Example: opencli twitter list-create "My List"');
+    }
+    if (name.length > NAME_MAX) {
+        throw new ArgumentError(`List name too long: ${name.length} chars (max ${NAME_MAX})`);
+    }
+    if (description.length > DESCRIPTION_MAX) {
+        throw new ArgumentError(`Description too long: ${description.length} chars (max ${DESCRIPTION_MAX})`);
+    }
+    if (modeRaw !== 'public' && modeRaw !== 'private') {
+        throw new ArgumentError(`Invalid mode: ${JSON.stringify(kwargs.mode)}. Expected "public" or "private".`);
+    }
+    return { listName: name, listDescription: description, listMode: modeRaw, privateFlag: modeRaw === 'private' };
+}
+
+function requireCreateListResult(result, expectedName, expectedMode) {
+    if (!result || typeof result !== 'object') {
+        throw new CommandExecutionError(`Unexpected result from twitter list-create: ${JSON.stringify(result)}`);
+    }
+    if (result.httpStatus === 401 || result.httpStatus === 403) {
+        throw new AuthRequiredError('x.com', `Twitter CreateList returned HTTP ${result.httpStatus}`);
+    }
+    if (!result.ok) {
+        const snippet = String(result.bodyText || '').slice(0, 300);
+        throw new CommandExecutionError(`HTTP ${result.httpStatus} from CreateList: ${snippet}`);
+    }
+    if (!result.bodyJson || typeof result.bodyJson !== 'object') {
+        throw new CommandExecutionError(`CreateList returned malformed JSON payload. Body: ${String(result.bodyText || '').slice(0, 300)}`);
+    }
+    const list = result.bodyJson?.data?.list;
+    if (!list || typeof list !== 'object') {
+        const errors = result.bodyJson?.errors;
+        if (Array.isArray(errors) && errors.length > 0) {
+            throw new CommandExecutionError(`CreateList failed: ${errors[0].message || JSON.stringify(errors[0])}`);
+        }
+        throw new CommandExecutionError(`CreateList returned no list payload. Body: ${String(result.bodyText || '').slice(0, 300)}`);
+    }
+    const id = String(list.id_str || list.id || '');
+    if (!/^\d+$/.test(id)) {
+        throw new CommandExecutionError('CreateList returned a list payload without a numeric list id.');
+    }
+    if (typeof list.name !== 'string' || !list.name.trim()) {
+        throw new CommandExecutionError('CreateList returned a list payload without a list name.');
+    }
+    if (list.name.trim() !== expectedName) {
+        throw new CommandExecutionError(`CreateList returned name ${JSON.stringify(list.name)}, expected ${JSON.stringify(expectedName)}.`);
+    }
+    const modeValue = typeof list.mode === 'string' ? list.mode : '';
+    if (!modeValue) {
+        throw new CommandExecutionError('CreateList returned a list payload without list mode.');
+    }
+    const mode = /private/i.test(modeValue) ? 'private' : 'public';
+    if (mode !== expectedMode) {
+        throw new CommandExecutionError(`CreateList returned mode ${mode}, expected ${expectedMode}.`);
+    }
+    return { createdList: list, listId: id, listMode: mode };
+}
+
+export function buildListCreateRow({ result, name, description, mode }) {
+    const { createdList, listId, listMode } = requireCreateListResult(result, name, mode);
+    return {
+        id: listId,
+        name: createdList.name,
+        description: typeof createdList.description === 'string' ? createdList.description : description,
+        mode: listMode,
+        status: 'success',
+    };
+}
+
+cli({
+    site: 'twitter',
+    name: 'list-create',
+    description: 'Create a new Twitter/X list (returns the new list id)',
+    access: 'write',
+    domain: 'x.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    args: [
+        { name: 'name', positional: true, type: 'string', required: true, help: `List name (max ${NAME_MAX} chars)` },
+        { name: 'description', type: 'string', default: '', help: `Optional list description (max ${DESCRIPTION_MAX} chars)` },
+        { name: 'mode', type: 'string', default: 'public', help: 'public | private' },
+    ],
+    columns: ['id', 'name', 'description', 'mode', 'status'],
+    func: async (page, kwargs) => {
+        const { listName: name, listDescription: description, listMode: mode, privateFlag: isPrivate } = parseListCreateArgs(kwargs);
+
+        await page.goto('https://x.com');
+        await page.wait(3);
+        const cookies = await page.getCookies({ url: 'https://x.com' });
+        const ct0 = cookies.find((c) => c.name === 'ct0')?.value || null;
+        if (!ct0) throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
+
+        // Hardcode queryId: it must match the FEATURES schema below.
+        // Letting resolveTwitterQueryId() drift would pull a newer queryId
+        // whose schema would reject our simplified features payload.
+        const queryId = CREATE_LIST_QUERY_ID;
+
+        const headers = JSON.stringify({
+            'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
+            'X-Csrf-Token': ct0,
+            'X-Twitter-Auth-Type': 'OAuth2Session',
+            'X-Twitter-Active-User': 'yes',
+            'Content-Type': 'application/json',
+        });
+        const body = JSON.stringify({
+            variables: { isPrivate, name, description },
+            features: FEATURES,
+            queryId,
+        });
+        const apiUrl = `/i/api/graphql/${queryId}/CreateList`;
+
+        const result = unwrapBrowserResult(await page.evaluate(`async () => {
+            const r = await fetch(${JSON.stringify(apiUrl)}, {
+                method: 'POST',
+                headers: ${headers},
+                credentials: 'include',
+                body: ${JSON.stringify(body)},
+            });
+            const bodyText = await r.text();
+            let bodyJson = null;
+            try { bodyJson = JSON.parse(bodyText); } catch {}
+            return { ok: r.ok, httpStatus: r.status, bodyJson, bodyText };
+        }`));
+
+        // Note: Twitter sometimes returns a non-fatal `errors` array (e.g. a
+        // strato DecodeException from a side-effect serializer) WHILE STILL
+        // creating the list. So check for a valid list payload FIRST and
+        // only treat errors as fatal if no list came back.
+        return [buildListCreateRow({ result, name, description, mode })];
+    },
+});

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

@@ -0,0 +1,169 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { buildListCreateRow, parseListCreateArgs } from './list-create.js';
+import './list-create.js';
+
+function createPayload(overrides = {}) {
+    return {
+        ok: true,
+        httpStatus: 200,
+        bodyText: '{}',
+        bodyJson: {
+            data: {
+                list: {
+                    id_str: '123456789',
+                    name: 'My List',
+                    description: 'A list',
+                    mode: 'Private',
+                    ...overrides,
+                },
+            },
+        },
+    };
+}
+
+describe('twitter list-create registration', () => {
+    it('registers the list-create command with the expected shape', () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        expect(cmd?.func).toBeTypeOf('function');
+        expect(cmd?.columns).toEqual(['id', 'name', 'description', 'mode', 'status']);
+        const nameArg = cmd?.args?.find((a) => a.name === 'name');
+        expect(nameArg).toBeTruthy();
+        expect(nameArg?.required).toBe(true);
+        expect(nameArg?.positional).toBe(true);
+        const modeArg = cmd?.args?.find((a) => a.name === 'mode');
+        expect(modeArg?.default).toBe('public');
+        const descArg = cmd?.args?.find((a) => a.name === 'description');
+        expect(descArg?.default).toBe('');
+    });
+
+    it('rejects empty name', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: '   ' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('rejects names over 25 chars', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: 'x'.repeat(26) })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('rejects descriptions over 100 chars', () => {
+        expect(() => parseListCreateArgs({ name: 'ok', description: 'x'.repeat(101) })).toThrow(ArgumentError);
+    });
+
+    it('rejects invalid mode', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        await expect(cmd.func({}, { name: 'ok', mode: 'secret' })).rejects.toBeInstanceOf(ArgumentError);
+    });
+
+    it('reads ct0 from cookies and unwraps Browser Bridge mutation envelopes', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf-token' }]),
+            evaluate: vi.fn().mockResolvedValue({ session: 'browser:default', data: createPayload() }),
+        };
+
+        const rows = await cmd.func(page, { name: 'My List', description: 'A list', mode: 'private' });
+
+        expect(page.goto).toHaveBeenCalledWith('https://x.com');
+        expect(page.wait).toHaveBeenCalledWith(3);
+        expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
+        expect(rows).toEqual([{ id: '123456789', name: 'My List', description: 'A list', mode: 'private', status: 'success' }]);
+    });
+
+    it('rejects missing ct0 before mutation', async () => {
+        const cmd = getRegistry().get('twitter/list-create');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([]),
+            evaluate: vi.fn(),
+        };
+
+        await expect(cmd.func(page, { name: 'My List' })).rejects.toBeInstanceOf(AuthRequiredError);
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('keeps non-fatal GraphQL errors when a valid created list payload exists', () => {
+        const row = buildListCreateRow({
+            result: {
+                ...createPayload(),
+                bodyJson: {
+                    ...createPayload().bodyJson,
+                    errors: [{ message: 'DecodeException' }],
+                },
+            },
+            name: 'My List',
+            description: 'A list',
+            mode: 'private',
+        });
+
+        expect(row).toEqual({ id: '123456789', name: 'My List', description: 'A list', mode: 'private', status: 'success' });
+    });
+
+    it('maps mutation auth and HTTP failures to typed errors', () => {
+        expect(() => buildListCreateRow({
+            result: { ok: false, httpStatus: 401, bodyText: 'login' },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(AuthRequiredError);
+
+        expect(() => buildListCreateRow({
+            result: { ok: false, httpStatus: 500, bodyText: 'server' },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(CommandExecutionError);
+    });
+
+    it('fails typed when the mutation response lacks post-condition evidence', () => {
+        for (const result of [
+            createPayload({ id_str: '', id: '' }),
+            createPayload({ name: '' }),
+            createPayload({ mode: '' }),
+        ]) {
+            expect(() => buildListCreateRow({
+                result,
+                name: 'My List',
+                description: '',
+                mode: 'public',
+            })).toThrow(CommandExecutionError);
+        }
+    });
+
+    it('fails typed when returned list name does not match the requested name', () => {
+        expect(() => buildListCreateRow({
+            result: createPayload({ name: 'Other List' }),
+            name: 'My List',
+            description: '',
+            mode: 'private',
+        })).toThrow(/expected "My List"/);
+    });
+
+    it('fails typed when returned list mode does not match requested mode', () => {
+        expect(() => buildListCreateRow({
+            result: createPayload({ mode: 'Public' }),
+            name: 'My List',
+            description: '',
+            mode: 'private',
+        })).toThrow(/expected private/);
+    });
+
+    it('fails typed when errors appear without a list payload', () => {
+        expect(() => buildListCreateRow({
+            result: {
+                ok: true,
+                httpStatus: 200,
+                bodyText: '{}',
+                bodyJson: { errors: [{ message: 'duplicate name' }] },
+            },
+            name: 'My List',
+            description: '',
+            mode: 'public',
+        })).toThrow(/duplicate name/);
+    });
+});

package/clis/twitter/list-remove.js

@@ -1,10 +1,10 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { resolveTwitterQueryId } from './shared.js';
-import { parseListsManagement } from './lists.js';
+import { getListsManagementInstructions, parseListsManagement } from './lists.js';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
-const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'IGgvgiOx4QZndDHuD3x9TQ';
 const LISTS_MANAGEMENT_QUERY_ID = '78UbkyXwXBD98IgUWXOy9g';
 
 const LISTS_MANAGEMENT_FEATURES = {
@@ -274,11 +274,18 @@ cli({
                 if (!r.ok) return { __error: 'HTTP ' + r.status };
                 return await r.json();
             }`);
-            const parsedAfter = listsAfter && !listsAfter.__error
-                ? parseListsManagement(listsAfter, new Set())
-                : [];
+            if (listsAfter && listsAfter.__error) {
+                throw new CommandExecutionError(`Could not verify list removal: ${listsAfter.__error}`);
+            }
+            if (!getListsManagementInstructions(listsAfter)) {
+                throw new CommandExecutionError('Could not verify list removal: unexpected lists payload shape');
+            }
+            const parsedAfter = parseListsManagement(listsAfter, new Set());
             const afterList = parsedAfter.find((l) => l.id === listId);
-            const memberCountAfter = afterList ? Number(afterList.members) || 0 : -1;
+            if (!afterList) {
+                throw new CommandExecutionError(`Could not verify list removal: list ${listId} missing from post-delete payload`);
+            }
+            const memberCountAfter = Number(afterList.members) || 0;
             if (memberCountAfter < memberCountBefore) {
                 verifiedBy = `member_count ${memberCountBefore} → ${memberCountAfter}`;
             } else {

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

@@ -1,7 +1,57 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
 import './list-remove.js';
 
+function buildListsPayload(listId = '123', memberCount = 10) {
+    return {
+        data: {
+            viewer: {
+                list_management_timeline: {
+                    timeline: {
+                        instructions: [{
+                            entries: [{
+                                entryId: 'owned-subscribed-list-module-0',
+                                content: {
+                                    items: [{
+                                        item: {
+                                            itemContent: {
+                                                list: {
+                                                    id_str: listId,
+                                                    name: 'My List',
+                                                    member_count: memberCount,
+                                                    subscriber_count: 0,
+                                                    mode: 'Public',
+                                                },
+                                            },
+                                        },
+                                    }],
+                                },
+                            }],
+                        }],
+                    },
+                },
+            },
+        },
+    };
+}
+
+function buildRemovePage(afterPayload) {
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        wait: vi.fn().mockResolvedValue(undefined),
+        getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'token' }]),
+        nativeClick: vi.fn().mockResolvedValue(undefined),
+        evaluate: vi.fn()
+            .mockResolvedValueOnce(null) // UserByScreenName queryId fallback
+            .mockResolvedValueOnce('user-1')
+            .mockResolvedValueOnce(null) // ListsManagement queryId fallback
+            .mockResolvedValueOnce(buildListsPayload('123', 10))
+            .mockResolvedValueOnce({ ok: true, needsNativeInteraction: true, rowClickX: 1, rowClickY: 2, saveClickX: 3, saveClickY: 4 })
+            .mockResolvedValueOnce(afterPayload),
+    };
+}
+
 describe('twitter list-remove registration', () => {
     it('registers the list-remove command with the expected shape', () => {
         const cmd = getRegistry().get('twitter/list-remove');
@@ -33,4 +83,28 @@ describe('twitter list-remove registration', () => {
         expect(page.wait).toHaveBeenCalledWith(3);
         expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
     });
+
+    it('does not treat post-delete fetch failure as successful member_count decrease', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage({ __error: 'HTTP 500' });
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not treat malformed post-delete payload as successful member_count decrease', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage({ data: {} });
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('does not treat a missing target list in post-delete payload as success', async () => {
+        const cmd = getRegistry().get('twitter/list-remove');
+        const page = buildRemovePage(buildListsPayload('456', 1));
+
+        await expect(cmd.func(page, { listId: '123', username: 'alice' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
 });

package/clis/twitter/list-tweets.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';
 
 const LIST_TWEETS_QUERY_ID = 'RlZzktZY_9wJynoepm8ZsA';
@@ -61,11 +61,13 @@ export function extractTimelineTweet(result, seen) {
     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 bio = user?.legacy?.description || '';
     const noteText = tw.note_tweet?.note_tweet_results?.result?.text;
     return {
         id: tw.rest_id,
         author: screenName,
         name: displayName,
+        bio,
         text: noteText || legacy.full_text || '',
         likes: legacy.favorite_count || 0,
         retweets: legacy.retweet_count || 0,
@@ -73,6 +75,8 @@ export function extractTimelineTweet(result, seen) {
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
         ...extractMedia(legacy),
+        card: extractCard(tw),
+        quoted_tweet: extractQuotedTweet(tw),
     };
 }
 
@@ -120,7 +124,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 list 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 the list\'s native (recency) ordering.' },
     ],
-    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url', 'has_media', 'media_urls'],
+    columns: ['id', 'author', 'bio', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url', 'has_media', 'media_urls', 'card', 'quoted_tweet'],
     func: async (page, kwargs) => {
         const listId = String(kwargs.listId || '').trim();
         if (!listId || !/^\d+$/.test(listId)) {

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

@@ -15,7 +15,7 @@ describe('twitter list-tweets parser', () => {
             core: {
                 user_results: {
                     result: {
-                        legacy: { screen_name: 'bob', name: 'Bob' },
+                        legacy: { screen_name: 'bob', name: 'Bob', description: 'List author bio' },
                     },
                 },
             },
@@ -24,6 +24,7 @@ describe('twitter list-tweets parser', () => {
             id: '99',
             author: 'bob',
             name: 'Bob',
+            bio: 'List author bio',
             text: 'hello list',
             likes: 3,
             retweets: 1,
@@ -32,6 +33,45 @@ describe('twitter list-tweets parser', () => {
             url: 'https://x.com/bob/status/99',
             has_media: false,
             media_urls: [],
+            card: null,
+            quoted_tweet: null,
+        });
+    });
+
+    it('surfaces quoted_tweet field on quote tweets (mini-tweet shape)', () => {
+        // 1778721843 stale-snapshot case from ml-scout — downstream consumers
+        // need quote-tweet content to render the embedded preview card.
+        const tweet = extractTimelineTweet({
+            rest_id: '500',
+            legacy: {
+                full_text: '总的来说，还是有个好爹',
+                is_quote_status: true,
+                quoted_status_id_str: '499',
+            },
+            core: { user_results: { result: { legacy: { screen_name: 'rwayne' } } } },
+            quoted_status_result: {
+                result: {
+                    rest_id: '499',
+                    legacy: {
+                        full_text: '罗某官二代背景考',
+                        created_at: 'Wed May 13 22:00:00 +0000 2026',
+                        extended_entities: {
+                            media: [{ type: 'photo', media_url_https: 'https://pbs.twimg.com/media/x.jpg' }],
+                        },
+                    },
+                    core: { user_results: { result: { legacy: { screen_name: 'alice', name: 'Alice' } } } },
+                },
+            },
+        }, new Set());
+        expect(tweet?.quoted_tweet).toEqual({
+            id: '499',
+            author: 'alice',
+            name: 'Alice',
+            text: '罗某官二代背景考',
+            created_at: 'Wed May 13 22:00:00 +0000 2026',
+            url: 'https://x.com/alice/status/499',
+            has_media: true,
+            media_urls: ['https://pbs.twimg.com/media/x.jpg'],
         });
     });
 

package/clis/twitter/lists.js

@@ -1,5 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
 const LISTS_QUERY_ID = '78UbkyXwXBD98IgUWXOy9g';
@@ -62,14 +62,35 @@ export function extractListEntry(entry, seen) {
     };
 }
 
-export function parseListsManagement(data, seen) {
-    const lists = [];
+// X 的 ListsManagementPageTimeline 把 /<user>/lists 整个页面的所有 section
+// 都塞在同一个 TimelineAddEntries instruction 里，靠 entry.entryId 前缀区分：
+//   - `owned-subscribed-list-module-*`  → 用户的 owned + subscribed list（要保留）
+//   - `list-to-follow-module-*`         → "Discover new Lists" 算法推荐（要剔除）
+//   - `cursor-*`                         → 分页游标（无 list 数据）
+// 旧版 parser 忽略 entryId 一律下钻，导致推荐 list 被当成自建/订阅泄漏出来。
+const OWNED_SUBSCRIBED_ENTRY_PREFIX = 'owned-subscribed-list-module-';
+
+export function isOwnedSubscribedEntry(entry) {
+    return typeof entry?.entryId === 'string'
+        && entry.entryId.startsWith(OWNED_SUBSCRIBED_ENTRY_PREFIX);
+}
+
+export function getListsManagementInstructions(data) {
     const instructions = data?.data?.viewer?.list_management_timeline?.timeline?.instructions
         || data?.data?.viewer_v2?.user_results?.result?.list_management_timeline?.timeline?.instructions
         || data?.data?.list_management_timeline?.timeline?.instructions
-        || [];
+        || data?.data?.data?.viewer?.list_management_timeline?.timeline?.instructions
+        || data?.data?.data?.viewer_v2?.user_results?.result?.list_management_timeline?.timeline?.instructions
+        || data?.data?.data?.list_management_timeline?.timeline?.instructions;
+    return Array.isArray(instructions) ? instructions : null;
+}
+
+export function parseListsManagement(data, seen) {
+    const lists = [];
+    const instructions = getListsManagementInstructions(data) || [];
     for (const inst of instructions) {
         for (const entry of inst.entries || []) {
+            if (!isOwnedSubscribedEntry(entry)) continue;
             const direct = extractListEntry(entry, seen);
             if (direct) {
                 lists.push(direct);
@@ -144,7 +165,13 @@ export const command = cli({
             throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch lists. queryId may have expired.`);
         }
         const seen = new Set();
+        if (!getListsManagementInstructions(data)) {
+            throw new CommandExecutionError('Twitter lists returned an unexpected payload shape');
+        }
         const lists = parseListsManagement(data, seen);
+        if (lists.length === 0) {
+            throw new EmptyResultError('twitter lists', 'No owned or subscribed lists found');
+        }
         return lists.slice(0, limit);
     },
 });