@jackwener/opencli 1.8.0 → 1.8.1

package/clis/twitter/following.js

@@ -1,10 +1,10 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
-import { normalizeTwitterScreenName, resolveTwitterQueryId, sanitizeQueryId, unwrapBrowserResult } from './shared.js';
+import { looksLikePrivateTwitterTimeline, normalizeTwitterScreenName, resolveTwitterQueryId, sanitizeQueryId, unwrapBrowserResult } from './shared.js';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 
-const FOLLOWING_QUERY_ID = 'zx6e-TLzRkeDO_a7p4b3JQ';  // Following fallback
-const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+const FOLLOWING_QUERY_ID = 'F42cDX8PDFxkbjjq6JrM2w';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'IGgvgiOx4QZndDHuD3x9TQ';
 const MAX_PAGINATION_PAGES = 100;
 
 const FEATURES = {
@@ -90,9 +90,13 @@ function extractUser(result) {
         return null;
     const core = result.core || {};
     const legacy = result.legacy || {};
+    const screenName = core.screen_name || legacy.screen_name || '';
+    if (!screenName) {
+        throw new CommandExecutionError('Malformed Twitter following user: missing screen_name');
+    }
     return {
-        screen_name: core.screen_name || legacy.screen_name || 'unknown',
-        name: core.name || legacy.name || 'unknown',
+        screen_name: screenName,
+        name: core.name || legacy.name || '',
         bio: legacy.description || result.profile_bio?.description || '',
         followers: legacy.followers_count || legacy.normal_followers_count || 0,
     };
@@ -221,6 +225,7 @@ cli({
         const allUsers = [];
         const seen = new Set();
         let cursor = null;
+        let lastRawResponse = null;
 
         // Runaway guard only; --limit and cursor exhaustion control normal pagination.
         for (let i = 0; i < MAX_PAGINATION_PAGES && allUsers.length < limit; i++) {
@@ -235,6 +240,7 @@ cli({
                     throw new AuthRequiredError('x.com', `Twitter following request failed (HTTP ${data.error})`);
                 throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch following list. queryId may have expired.`);
             }
+            lastRawResponse = data;
             const { users, nextCursor } = parseFollowing(data);
             for (const u of users) {
                 if (!seen.has(u.screen_name)) {
@@ -248,6 +254,9 @@ cli({
         }
 
         if (allUsers.length === 0) {
+            if (looksLikePrivateTwitterTimeline(lastRawResponse)) {
+                throw new EmptyResultError('twitter following', `No following data returned for @${targetUser} (the target account may have set their following list to private)`);
+            }
             throw new EmptyResultError('twitter following', `No following accounts found for @${targetUser}`);
         }
 

package/clis/twitter/following.test.js

@@ -53,6 +53,27 @@ describe('twitter following helpers', () => {
         expect(user?.screen_name).toBe('bob');
     });
 
+    it('typed-fails when upstream omits screen_name identity', () => {
+        expect(() => __test__.extractUser({
+            __typename: 'User',
+            legacy: { description: 'no names', followers_count: 7 },
+        })).toThrow(CommandExecutionError);
+    });
+
+    it('surfaces empty name display when upstream omits only name', () => {
+        const user = __test__.extractUser({
+            __typename: 'User',
+            core: { screen_name: 'alice' },
+            legacy: { description: 'no display name', followers_count: 7 },
+        });
+        expect(user).toMatchObject({
+            screen_name: 'alice',
+            name: '',
+            bio: 'no display name',
+            followers: 7,
+        });
+    });
+
     it('parses following timeline with users and cursor', () => {
         const payload = {
             data: {
@@ -327,4 +348,12 @@ describe('twitter following command', () => {
 
         await expect(command.func(page, { user: 'elonmusk', limit: 10 })).rejects.toBeInstanceOf(EmptyResultError);
     });
+
+    it('surfaces the private-following privacy hint when result.timeline is empty', async () => {
+        const command = getRegistry().get('twitter/following');
+        const page = createFollowingPage([{ data: { user: { result: { __typename: 'User', timeline: {} } } } }]);
+
+        await expect(command.func(page, { user: 'simonw', limit: 10 }))
+            .rejects.toMatchObject({ hint: expect.stringContaining('following list to private') });
+    });
 });

package/clis/twitter/likes.js

@@ -1,9 +1,9 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
-import { normalizeTwitterScreenName, resolveTwitterQueryId, sanitizeQueryId, extractMedia, unwrapBrowserResult } from './shared.js';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { looksLikePrivateTwitterTimeline, normalizeTwitterScreenName, resolveTwitterQueryId, sanitizeQueryId, extractMedia, unwrapBrowserResult } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
-const LIKES_QUERY_ID = 'RozQdCp4CilQzrcuU0NY5w';
-const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
+const LIKES_QUERY_ID = 'CDWHmpZeSdIJ3HGeRbNm0w';
+const USER_BY_SCREEN_NAME_QUERY_ID = 'IGgvgiOx4QZndDHuD3x9TQ';
 const MAX_PAGINATION_PAGES = 100;
 const FEATURES = {
     rweb_video_screen_enabled: false,
@@ -202,6 +202,7 @@ cli({
         const allTweets = [];
         const seen = new Set();
         let cursor = null;
+        let lastRawResponse = null;
         // Runaway guard only; --limit and cursor exhaustion control normal pagination.
         for (let i = 0; i < MAX_PAGINATION_PAGES && allTweets.length < limit; i++) {
             const fetchCount = Math.min(100, limit - allTweets.length + 10);
@@ -215,12 +216,19 @@ cli({
                     throw new CommandExecutionError(`HTTP ${data.error}: Failed to fetch likes. queryId may have expired.`);
                 break;
             }
+            lastRawResponse = data;
             const { tweets, nextCursor } = parseLikes(data, seen);
             allTweets.push(...tweets);
             if (!nextCursor || nextCursor === cursor)
                 break;
             cursor = nextCursor;
         }
+        if (allTweets.length === 0) {
+            if (looksLikePrivateTwitterTimeline(lastRawResponse)) {
+                throw new EmptyResultError('twitter likes', `No likes returned for @${username} (Likes are private by default on X; only the account owner can view their own likes)`);
+            }
+            throw new EmptyResultError('twitter likes', `No likes found for @${username}`);
+        }
         const trimmed = allTweets.slice(0, limit);
         return applyTopByEngagement(trimmed, kwargs['top-by-engagement']);
     },

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-remove.js

@@ -4,7 +4,7 @@ import { resolveTwitterQueryId } from './shared.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 = {

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);
+    });
 });

package/clis/twitter/quote.js

@@ -62,10 +62,15 @@ async function submitQuote(page, text, tweetId) {
                 return { ok: false, message: 'Quote target did not render in the composer. The source tweet may be deleted or restricted.' };
             }
 
-            const buttons = Array.from(
-                document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
-            );
-            const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+            let btn = null;
+            for (let i = 0; i < 30; i++) {
+                const buttons = Array.from(
+                    document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
+                );
+                btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+                if (btn) break;
+                await new Promise(r => setTimeout(r, 500));
+            }
             if (!btn) {
                 return { ok: false, message: 'Tweet button is disabled or not found.' };
             }