@jackwener/opencli 1.7.22 → 1.8.1

package/clis/twitter/lists.test.js

@@ -1,5 +1,7 @@
 import { describe, expect, it } from 'vitest';
-import { extractListEntry, parseListsManagement } from './lists.js';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { extractListEntry, isOwnedSubscribedEntry, parseListsManagement } from './lists.js';
 
 describe('twitter lists parser', () => {
     it('extracts a list entry with full metadata', () => {
@@ -56,7 +58,7 @@ describe('twitter lists parser', () => {
         expect(extractListEntry({ content: { itemContent: {} } }, new Set())).toBeNull();
     });
 
-    it('parses ListsManagementPageTimeline payload instructions', () => {
+    it('parses ListsManagementPageTimeline payload instructions (real shape: nested module items)', () => {
         const payload = {
             data: {
                 viewer: {
@@ -64,23 +66,92 @@ describe('twitter lists parser', () => {
                         timeline: {
                             instructions: [
                                 {
+                                    type: 'TimelineAddEntries',
                                     entries: [
                                         {
-                                            entryId: 'owned-list-1',
+                                            entryId: 'owned-subscribed-list-module-0',
                                             content: {
-                                                itemContent: {
-                                                    list: { id_str: '1', name: 'Crypto', member_count: 44, subscriber_count: 8747, mode: 'Public' },
-                                                },
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-1',
+                                                        item: {
+                                                            itemContent: {
+                                                                itemType: 'TimelineTwitterList',
+                                                                list: { id_str: '1', name: 'AI & Agents', member_count: 33, subscriber_count: 0, mode: 'Private' },
+                                                            },
+                                                        },
+                                                    },
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-2',
+                                                        item: {
+                                                            itemContent: {
+                                                                itemType: 'TimelineTwitterList',
+                                                                list: { id_str: '2', name: 'Anthropic Team', member_count: 10, subscriber_count: 0, mode: 'Public' },
+                                                            },
+                                                        },
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+        };
+        const result = parseListsManagement(payload, new Set());
+        expect(result).toHaveLength(2);
+        expect(result[0]).toMatchObject({ id: '1', name: 'AI & Agents', mode: 'private' });
+        expect(result[1]).toMatchObject({ id: '2', name: 'Anthropic Team', mode: 'public' });
+    });
+
+    it('skips "Discover new Lists" recommendations (list-to-follow-module-*)', () => {
+        // 真实 X.com /<user>/lists 响应：Discover 推荐 + Your Lists 同 instruction，
+        // 区别只在 entry.entryId 前缀。Parser 必须按前缀剔除推荐。
+        const payload = {
+            data: {
+                viewer: {
+                    list_management_timeline: {
+                        timeline: {
+                            instructions: [
+                                {
+                                    type: 'TimelineAddEntries',
+                                    entries: [
+                                        {
+                                            entryId: 'list-to-follow-module-2050754937725386752',
+                                            content: {
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'list-to-follow-module-XYZ-list-1597593475389984769',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '1597593475389984769', name: 'Crypto', member_count: 44, subscriber_count: 8947, mode: 'Public' } } },
+                                                    },
+                                                    {
+                                                        entryId: 'list-to-follow-module-XYZ-list-1499395616262217730',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '1499395616262217730', name: 'Crypto Blockchain', member_count: 24, subscriber_count: 1166, mode: 'Public' } } },
+                                                    },
+                                                ],
                                             },
                                         },
                                         {
-                                            entryId: 'subscribed-list-2',
+                                            entryId: 'owned-subscribed-list-module-0',
                                             content: {
-                                                itemContent: {
-                                                    list: { id_str: '2', name: 'AI', member_count: 15, subscriber_count: 0, mode: 'Private' },
-                                                },
+                                                entryType: 'TimelineTimelineModule',
+                                                items: [
+                                                    {
+                                                        entryId: 'owned-subscribed-list-module-0-list-2044679538156912976',
+                                                        item: { itemContent: { itemType: 'TimelineTwitterList', list: { id_str: '2044679538156912976', name: 'AI & Agents', member_count: 33, subscriber_count: 0, mode: 'Private' } } },
+                                                    },
+                                                ],
                                             },
                                         },
+                                        {
+                                            entryId: 'cursor-bottom-2050754937725386750',
+                                            content: { entryType: 'TimelineTimelineCursor' },
+                                        },
                                     ],
                                 },
                             ],
@@ -90,9 +161,19 @@ describe('twitter lists parser', () => {
             },
         };
         const result = parseListsManagement(payload, new Set());
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({ id: '1', name: 'Crypto', mode: 'public' });
-        expect(result[1]).toMatchObject({ id: '2', name: 'AI', mode: 'private' });
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({ id: '2044679538156912976', name: 'AI & Agents' });
+        // No Crypto/Blockchain leakage
+        expect(result.find(l => l.name === 'Crypto')).toBeUndefined();
+        expect(result.find(l => l.name === 'Crypto Blockchain')).toBeUndefined();
+    });
+
+    it('isOwnedSubscribedEntry classifies entryIds', () => {
+        expect(isOwnedSubscribedEntry({ entryId: 'owned-subscribed-list-module-0' })).toBe(true);
+        expect(isOwnedSubscribedEntry({ entryId: 'list-to-follow-module-2050754937725386752' })).toBe(false);
+        expect(isOwnedSubscribedEntry({ entryId: 'cursor-bottom-XYZ' })).toBe(false);
+        expect(isOwnedSubscribedEntry({})).toBe(false);
+        expect(isOwnedSubscribedEntry({ entryId: null })).toBe(false);
     });
 
     it('returns empty list for malformed payload', () => {
@@ -100,13 +181,23 @@ describe('twitter lists parser', () => {
         expect(parseListsManagement({ data: {} }, new Set())).toEqual([]);
     });
 
-    it('dedupes across repeated entries', () => {
-        const entryA = { content: { itemContent: { list: { id_str: '1', name: 'A' } } } };
+    it('dedupes across repeated entries within owned-subscribed module', () => {
+        const itemA = {
+            entryId: 'owned-subscribed-list-module-0-list-1',
+            item: { itemContent: { list: { id_str: '1', name: 'A' } } },
+        };
         const payload = {
             data: {
                 viewer: {
                     list_management_timeline: {
-                        timeline: { instructions: [{ entries: [entryA, entryA] }] },
+                        timeline: {
+                            instructions: [{
+                                entries: [{
+                                    entryId: 'owned-subscribed-list-module-0',
+                                    content: { items: [itemA, itemA] },
+                                }],
+                            }],
+                        },
                     },
                 },
             },
@@ -114,4 +205,49 @@ describe('twitter lists parser', () => {
         const result = parseListsManagement(payload, new Set());
         expect(result).toHaveLength(1);
     });
+
+    it('fails malformed command payloads as parser drift instead of empty success', async () => {
+        const command = getRegistry().get('twitter/lists');
+        const page = {
+            getCookies: async () => [{ name: 'ct0', value: 'token' }],
+            evaluate: async (script) => {
+                if (script.includes('placeholder.json')) return null;
+                return { data: {} };
+            },
+        };
+
+        await expect(command.func(page, { limit: 10 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('treats a recommendation-only timeline as a true empty result', async () => {
+        const command = getRegistry().get('twitter/lists');
+        const page = {
+            getCookies: async () => [{ name: 'ct0', value: 'token' }],
+            evaluate: async (script) => {
+                if (script.includes('placeholder.json')) return null;
+                return {
+                    data: {
+                        viewer: {
+                            list_management_timeline: {
+                                timeline: {
+                                    instructions: [{
+                                        entries: [{
+                                            entryId: 'list-to-follow-module-1',
+                                            content: {
+                                                items: [{
+                                                    item: { itemContent: { list: { id_str: '9', name: 'Recommended' } } },
+                                                }],
+                                            },
+                                        }],
+                                    }],
+                                },
+                            },
+                        },
+                    },
+                };
+            },
+        };
+
+        await expect(command.func(page, { limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
+    });
 });

package/clis/twitter/notifications.js

@@ -72,14 +72,14 @@ cli({
                         return;
                     let item = itemContent?.notification_results?.result || itemContent?.tweet_results?.result || itemContent;
                     let actionText = 'Notification';
-                    let author = 'unknown';
+                    let author = '';
                     let text = '';
                     let urlStr = '';
                     if (item.__typename === 'TimelineNotification') {
                         text = item.rich_message?.text || item.message?.text || '';
                         const fromUser = item.template?.from_users?.[0]?.user_results?.result;
                         // Twitter moved screen_name from legacy to core
-                        author = fromUser?.core?.screen_name || fromUser?.legacy?.screen_name || 'unknown';
+                        author = fromUser?.core?.screen_name || fromUser?.legacy?.screen_name || '';
                         urlStr = item.notification_url?.url || '';
                         actionText = item.notification_icon || 'Activity';
                         const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
@@ -94,14 +94,14 @@ cli({
                     else if (item.__typename === 'TweetNotification') {
                         const tweet = item.tweet_result?.result;
                         const tweetUser = tweet?.core?.user_results?.result;
-                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
+                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || '';
                         text = tweet?.note_tweet?.note_tweet_results?.result?.text || tweet?.legacy?.full_text || item.message?.text || '';
                         actionText = 'Mention/Reply';
                         urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
                     }
                     else if (item.__typename === 'Tweet') {
                         const tweetUser = item.core?.user_results?.result;
-                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
+                        author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || '';
                         text = item.note_tweet?.note_tweet_results?.result?.text || item.legacy?.full_text || '';
                         actionText = 'Mention';
                         urlStr = `https://x.com/i/status/${item.rest_id}`;

package/clis/twitter/post.js

@@ -2,6 +2,7 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { isRecoverableFileInputError } from './utils.js';
 
 const MAX_IMAGES = 4;
 const UPLOAD_POLL_MS = 500;
@@ -142,6 +143,55 @@ async function waitForImageUpload(page, expectedCount) {
     })()`);
 }
 
+async function attachImagesViaDataTransfer(page, absPaths) {
+    const files = absPaths.map((absPath) => {
+        const ext = path.extname(absPath).toLowerCase();
+        const mime = ext === '.png'
+            ? 'image/png'
+            : ext === '.gif'
+                ? 'image/gif'
+                : ext === '.webp'
+                    ? 'image/webp'
+                    : 'image/jpeg';
+        return {
+            name: path.basename(absPath),
+            mime,
+            base64: fs.readFileSync(absPath).toString('base64'),
+        };
+    });
+    const upload = await page.evaluate(`(() => {
+        const input = document.querySelector(${JSON.stringify(FILE_INPUT_SELECTOR)});
+        if (!input) return { ok: false, error: 'No file input found' };
+        const dt = new DataTransfer();
+        for (const file of ${JSON.stringify(files)}) {
+            const bin = atob(file.base64);
+            const bytes = new Uint8Array(bin.length);
+            for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+            dt.items.add(new File([bytes], file.name, { type: file.mime }));
+        }
+        let assigned = false;
+        try {
+            Object.defineProperty(input, 'files', { value: dt.files, writable: false, configurable: true });
+            assigned = input.files && input.files.length >= ${JSON.stringify(absPaths.length)};
+        } catch(e) {
+            try {
+                const nativeInputFileSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'files');
+                if (nativeInputFileSetter && nativeInputFileSetter.set) {
+                    nativeInputFileSetter.set.call(input, dt.files);
+                    assigned = input.files && input.files.length >= ${JSON.stringify(absPaths.length)};
+                }
+            } catch(e2) { /* ignore */ }
+        }
+        if (!assigned) return { ok: false, error: 'Could not assign files to input' };
+        input.dispatchEvent(new Event('change', { bubbles: true }));
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+        return { ok: true };
+    })()`);
+    if (!upload?.ok) {
+        throw new CommandExecutionError(`Image upload failed (base64 fallback): ${upload?.error ?? 'unknown error'}`);
+    }
+}
+
 async function submitTweet(page, text) {
     const clickResult = await page.evaluate(`(async () => {
         try {
@@ -224,11 +274,19 @@ cli({
         // Attach media before inserting text. Uploading media after Draft.js has
         // text can re-render/reset the editor, causing image-only posts.
         if (absPaths.length > 0) {
-            if (!page.setFileInput) {
-                throw new CommandExecutionError('Browser extension does not support file upload. Please update the extension.');
-            }
             await page.wait({ selector: FILE_INPUT_SELECTOR, timeout: 20 });
-            await page.setFileInput(absPaths, FILE_INPUT_SELECTOR);
+            if (page.setFileInput) {
+                try {
+                    await page.setFileInput(absPaths, FILE_INPUT_SELECTOR);
+                } catch (err) {
+                    if (!isRecoverableFileInputError(err)) {
+                        throw err;
+                    }
+                    await attachImagesViaDataTransfer(page, absPaths);
+                }
+            } else {
+                await attachImagesViaDataTransfer(page, absPaths);
+            }
             const uploadState = await waitForImageUpload(page, absPaths.length);
             if (!uploadState?.ok) {
                 return [{ status: 'failed', message: uploadState?.message ?? `Image upload timed out (${UPLOAD_TIMEOUT_MS / 1000}s).`, text }];

package/clis/twitter/post.test.js

@@ -11,6 +11,7 @@ vi.mock('node:fs', async (importOriginal) => {
                 return undefined;
             return { isFile: () => true };
         }),
+        readFileSync: vi.fn(() => Buffer.from([0x89, 0x50, 0x4e, 0x47])),
     };
 });
 
@@ -123,10 +124,41 @@ describe('twitter post command', () => {
         await expect(command.func(page, { text: 'hi', images: 'photo.bmp' })).rejects.toThrow('Unsupported image format');
     });
 
-    it('throws when page.setFileInput is not available', async () => {
+    it('falls back to DataTransfer upload when page.setFileInput is not available', async () => {
         const command = getCommand();
-        const page = makePage([], { setFileInput: undefined });
-        await expect(command.func(page, { text: 'hi', images: 'a.png' })).rejects.toThrow('Browser extension does not support file upload');
+        const page = makePage([
+            { ok: true }, // DataTransfer fallback
+            { ok: true, previewCount: 1 }, // upload polling
+            { ok: true }, // focus composer
+            { ok: true }, // verify native insertText
+            { ok: true }, // click post
+            { ok: true, message: 'Tweet posted successfully.' },
+        ], { setFileInput: undefined });
+
+        const result = await command.func(page, { text: 'hi', images: 'a.png' });
+
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'hi' }]);
+        expect(page.evaluate.mock.calls[0][0]).toContain('new DataTransfer()');
+        expect(page.evaluate.mock.calls[0][0]).toContain('Could not assign files to input');
+    });
+
+    it('falls back to DataTransfer upload when CDP rejects file input as not allowed', async () => {
+        const command = getCommand();
+        const setFileInput = vi.fn().mockRejectedValue(new Error('NotAllowedError: Not allowed'));
+        const page = makePage([
+            { ok: true }, // DataTransfer fallback
+            { ok: true, previewCount: 1 }, // upload polling
+            { ok: true }, // focus composer
+            { ok: true }, // verify native insertText
+            { ok: true }, // click post
+            { ok: true, message: 'Tweet posted successfully.' },
+        ], { setFileInput });
+
+        const result = await command.func(page, { text: 'with fallback', images: 'a.png' });
+
+        expect(result).toEqual([{ status: 'success', message: 'Tweet posted successfully.', text: 'with fallback' }]);
+        expect(setFileInput).toHaveBeenCalledWith(['/abs/a.png'], 'input[type="file"][data-testid="fileInput"]');
+        expect(page.evaluate.mock.calls[0][0]).toContain('new DataTransfer()');
     });
 
     it('uploads images before inserting text so media re-renders cannot erase the tweet text', async () => {

package/clis/twitter/profile.js

@@ -1,8 +1,48 @@
-import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { normalizeTwitterScreenName, resolveTwitterQueryId, unwrapBrowserResult } from './shared.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';
+
+function isPlainObject(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function stringField(value) {
+    return typeof value === 'string' ? value : '';
+}
+
+export function mapTwitterProfileResult(result, screenName) {
+    if (!isPlainObject(result)) {
+        throw new CommandExecutionError(`Twitter profile response for @${screenName} is malformed`);
+    }
+    const hasLegacy = isPlainObject(result.legacy);
+    const hasCore = isPlainObject(result.core);
+    if (!hasLegacy && !hasCore) {
+        throw new CommandExecutionError(`Twitter profile response for @${screenName} is missing profile fields`);
+    }
+    const legacy = hasLegacy ? result.legacy : {};
+    const core = hasCore ? result.core : {};
+    if (!stringField(core.screen_name) && !stringField(legacy.screen_name) && !stringField(core.name) && !stringField(legacy.name) && !stringField(core.created_at) && !stringField(legacy.created_at)) {
+        throw new CommandExecutionError(`Twitter profile response for @${screenName} is missing profile identity fields`);
+    }
+    const location = isPlainObject(result.location) ? result.location : {};
+    const expandedUrl = legacy.entities?.url?.urls?.[0]?.expanded_url || '';
+    return [{
+        screen_name: stringField(core.screen_name) || stringField(legacy.screen_name) || screenName,
+        name: stringField(core.name) || stringField(legacy.name),
+        bio: stringField(legacy.description),
+        location: stringField(location.location) || stringField(legacy.location),
+        url: stringField(expandedUrl),
+        followers: legacy.followers_count || 0,
+        following: legacy.friends_count || 0,
+        tweets: legacy.statuses_count || 0,
+        likes: legacy.favourites_count || 0,
+        verified: Boolean(result.is_blue_verified || legacy.verified),
+        created_at: stringField(core.created_at) || stringField(legacy.created_at),
+    }];
+}
+
 cli({
     site: 'twitter',
     name: 'profile',
@@ -46,7 +86,7 @@ cli({
         if (!ct0)
             throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
         const queryId = await resolveTwitterQueryId(page, 'UserByScreenName', USER_BY_SCREEN_NAME_QUERY_ID);
-        const result = await page.evaluate(`
+        const rawResult = unwrapBrowserResult(await page.evaluate(`
       async () => {
         const screenName = "${username}";
         const ct0 = ${JSON.stringify(ct0)};
@@ -82,34 +122,47 @@ cli({
           + encodeURIComponent(variables)
           + '&features=' + encodeURIComponent(features);
 
-        const resp = await fetch(url, {headers, credentials: 'include'});
-        if (!resp.ok) return {error: 'HTTP ' + resp.status, hint: 'User may not exist or queryId expired'};
-        const d = await resp.json();
+        let resp;
+        try {
+          resp = await fetch(url, {headers, credentials: 'include'});
+        } catch (error) {
+          return {ok: false, error: 'Twitter profile request failed: ' + String(error && error.message || error)};
+        }
+        if (!resp.ok) {
+          return {
+            ok: false,
+            auth: resp.status === 401 || resp.status === 403,
+            error: 'HTTP ' + resp.status,
+            hint: 'User may not exist, auth may be required, or queryId expired'
+          };
+        }
+        let d;
+        try {
+          d = await resp.json();
+        } catch (error) {
+          return {ok: false, error: 'Twitter profile response was not JSON: ' + String(error && error.message || error)};
+        }
 
         const result = d.data?.user?.result;
-        if (!result) return {error: 'User @' + screenName + ' not found'};
-
-        const legacy = result.legacy || {};
-        const expandedUrl = legacy.entities?.url?.urls?.[0]?.expanded_url || '';
-
-        return [{
-          screen_name: legacy.screen_name || screenName,
-          name: legacy.name || '',
-          bio: legacy.description || '',
-          location: legacy.location || '',
-          url: expandedUrl,
-          followers: legacy.followers_count || 0,
-          following: legacy.friends_count || 0,
-          tweets: legacy.statuses_count || 0,
-          likes: legacy.favourites_count || 0,
-          verified: result.is_blue_verified || legacy.verified || false,
-          created_at: legacy.created_at || '',
-        }];
+        if (!result) return {ok: false, notFound: true, error: 'User @' + screenName + ' not found'};
+        return {ok: true, result};
       }
-    `);
-        if (result?.error) {
-            throw new CommandExecutionError(result.error + (result.hint ? ` (${result.hint})` : ''));
+    `));
+        if (!isPlainObject(rawResult)) {
+            throw new CommandExecutionError('Twitter profile response payload is malformed');
+        }
+        if (!rawResult.ok) {
+            const message = rawResult.error + (rawResult.hint ? ` (${rawResult.hint})` : '');
+            if (rawResult.auth) {
+                throw new AuthRequiredError('x.com', message);
+            }
+            if (rawResult.notFound) {
+                throw new EmptyResultError('twitter profile', message);
+            }
+            throw new CommandExecutionError(message);
         }
-        return result || [];
+        return mapTwitterProfileResult(rawResult.result, username);
     }
 });
+
+export const __test__ = { mapTwitterProfileResult };

package/clis/twitter/profile.test.js

@@ -1,9 +1,73 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
-import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
-import './profile.js';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { __test__ } from './profile.js';
 
 describe('twitter profile command', () => {
+    it('maps current result.core profile fields while preserving legacy fallback fields', () => {
+        const rows = __test__.mapTwitterProfileResult({
+            core: {
+                screen_name: 'AstroHanRay',
+                name: 'AstroHan',
+                created_at: 'Sun Mar 20 00:00:00 +0000 2011',
+            },
+            legacy: {
+                screen_name: null,
+                name: null,
+                description: 'bio text',
+                location: 'legacy location',
+                followers_count: 117,
+                friends_count: 12,
+                statuses_count: 30,
+                favourites_count: 4,
+                verified: false,
+                entities: { url: { urls: [{ expanded_url: 'https://example.com' }] } },
+            },
+            location: { location: 'core location' },
+            is_blue_verified: true,
+        }, 'fallback');
+
+        expect(rows).toEqual([{
+            screen_name: 'AstroHanRay',
+            name: 'AstroHan',
+            bio: 'bio text',
+            location: 'core location',
+            url: 'https://example.com',
+            followers: 117,
+            following: 12,
+            tweets: 30,
+            likes: 4,
+            verified: true,
+            created_at: 'Sun Mar 20 00:00:00 +0000 2011',
+        }]);
+    });
+
+    it('falls back to legacy profile fields for older UserByScreenName responses', () => {
+        const rows = __test__.mapTwitterProfileResult({
+            legacy: {
+                screen_name: 'legacy_user',
+                name: 'Legacy Name',
+                created_at: 'Wed Jan 01 00:00:00 +0000 2020',
+                location: 'legacy location',
+            },
+        }, 'fallback');
+
+        expect(rows[0]).toMatchObject({
+            screen_name: 'legacy_user',
+            name: 'Legacy Name',
+            created_at: 'Wed Jan 01 00:00:00 +0000 2020',
+            location: 'legacy location',
+        });
+    });
+
+    it('throws typed when the profile result is structurally malformed', () => {
+        expect(() => __test__.mapTwitterProfileResult(null, 'jack')).toThrow(CommandExecutionError);
+        expect(() => __test__.mapTwitterProfileResult([], 'jack')).toThrow(CommandExecutionError);
+        expect(() => __test__.mapTwitterProfileResult({}, 'jack')).toThrow(CommandExecutionError);
+        expect(() => __test__.mapTwitterProfileResult({ __typename: 'UserUnavailable' }, 'jack')).toThrow(CommandExecutionError);
+        expect(() => __test__.mapTwitterProfileResult({ legacy: {}, core: {} }, 'jack')).toThrow(CommandExecutionError);
+    });
+
     it('rejects invalid explicit usernames before navigation', async () => {
         const command = getRegistry().get('twitter/profile');
         const page = {
@@ -36,4 +100,51 @@ describe('twitter profile command', () => {
         expect(page.goto).toHaveBeenCalledTimes(1);
         expect(page.getCookies).not.toHaveBeenCalled();
     });
+
+    it('unwraps Browser Bridge envelopes around UserByScreenName payloads', async () => {
+        const command = getRegistry().get('twitter/profile');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
+            evaluate: vi.fn()
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({
+                    session: 'site:twitter',
+                    data: {
+                        ok: true,
+                        result: {
+                            core: { screen_name: 'core_user', name: 'Core User', created_at: 'now' },
+                            legacy: { description: 'bio' },
+                        },
+                    },
+                }),
+        };
+
+        await expect(command.func(page, { username: 'core_user' })).resolves.toEqual([
+            expect.objectContaining({
+                screen_name: 'core_user',
+                name: 'Core User',
+                bio: 'bio',
+                created_at: 'now',
+            }),
+        ]);
+    });
+
+    it('maps GraphQL auth and not-found envelopes to typed failures', async () => {
+        const command = getRegistry().get('twitter/profile');
+        const createPage = (payload) => ({
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn().mockResolvedValue([{ name: 'ct0', value: 'csrf' }]),
+            evaluate: vi.fn().mockResolvedValueOnce(null).mockResolvedValueOnce(payload),
+        });
+
+        await expect(command.func(createPage({ ok: false, auth: true, error: 'HTTP 401' }), { username: 'jack' }))
+            .rejects.toBeInstanceOf(AuthRequiredError);
+        await expect(command.func(createPage({ ok: false, notFound: true, error: 'User @missing not found' }), { username: 'missing' }))
+            .rejects.toBeInstanceOf(EmptyResultError);
+        await expect(command.func(createPage({ session: 'site:twitter', data: [] }), { username: 'jack' }))
+            .rejects.toBeInstanceOf(CommandExecutionError);
+    });
 });