@jackwener/opencli 1.7.18 → 1.7.19

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

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
-import './list-add.js';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { buildListAddMemberRow } from './list-add.js';
 
 describe('twitter list-add registration', () => {
     it('registers the list-add command with the expected shape', () => {
@@ -34,4 +35,99 @@ describe('twitter list-add registration', () => {
         expect(page.wait).toHaveBeenCalledWith(3);
         expect(page.getCookies).toHaveBeenCalledWith({ url: 'https://x.com' });
     });
+
+    it('rejects invalid user input before navigation', async () => {
+        const cmd = getRegistry().get('twitter/list-add');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            getCookies: vi.fn(),
+            evaluate: vi.fn(),
+        };
+
+        await expect(cmd.func(page, { listId: 'abc', username: 'alice' })).rejects.toBeInstanceOf(ArgumentError);
+        await expect(cmd.func(page, { listId: '123', username: '' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+
+    it('builds success rows when member_count increases despite non-fatal decode errors', () => {
+        const row = buildListAddMemberRow({
+            addResult: {
+                httpOk: true,
+                status: 200,
+                mc: 11,
+                isMember: true,
+                errors: [{ path: ['data', 'list', 'default_banner_media_results'], message: 'decode failed' }],
+            },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        });
+
+        expect(row).toMatchObject({
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+            status: 'success',
+        });
+        expect(row.message).toContain('member_count 10 → 11');
+    });
+
+    it('treats unchanged member_count as noop only when membership is confirmed', () => {
+        const row = buildListAddMemberRow({
+            addResult: { httpOk: true, status: 200, mc: 10, isMember: true, errors: null },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        });
+
+        expect(row.status).toBe('noop');
+        expect(row.message).toBe('@alice is already a member of list 123');
+    });
+
+    it('fails typed when unchanged member_count does not confirm membership', () => {
+        expect(() => buildListAddMemberRow({
+            addResult: { httpOk: true, status: 200, mc: 10, isMember: false, errors: null },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        })).toThrow(CommandExecutionError);
+    });
+
+    it('fails typed when member_count decreases unexpectedly', () => {
+        expect(() => buildListAddMemberRow({
+            addResult: { httpOk: true, status: 200, mc: 9, isMember: true, errors: null },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        })).toThrow(/decreased unexpectedly/);
+    });
+
+    it('fails typed when GraphQL response has no usable member_count', () => {
+        expect(() => buildListAddMemberRow({
+            addResult: {
+                httpOk: true,
+                status: 200,
+                mc: undefined,
+                isMember: null,
+                errors: [{ message: 'List is unavailable', path: ['data', 'list'] }],
+            },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        })).toThrow(/List is unavailable/);
+
+        expect(() => buildListAddMemberRow({
+            addResult: { httpOk: true, status: 200, mc: null, isMember: null, errors: { message: 'not an array' } },
+            memberCountBefore: 10,
+            listId: '123',
+            username: 'alice',
+            userId: '42',
+        })).toThrow(/no member_count/);
+    });
 });

package/clis/twitter/list-tweets.js

@@ -1,9 +1,11 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
 import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { extractMedia } from './shared.js';
 import { TWITTER_BEARER_TOKEN, applyTopByEngagement } from './utils.js';
 
 const LIST_TWEETS_QUERY_ID = 'RlZzktZY_9wJynoepm8ZsA';
 const OPERATION_NAME = 'ListLatestTweetsTimeline';
+const MAX_PAGINATION_PAGES = 100;
 
 const FEATURES = {
     rweb_video_screen_enabled: false,
@@ -70,6 +72,7 @@ export function extractTimelineTweet(result, seen) {
         replies: legacy.reply_count || 0,
         created_at: legacy.created_at || '',
         url: `https://x.com/${screenName}/status/${tw.rest_id}`,
+        ...extractMedia(legacy),
     };
 }
 
@@ -118,7 +121,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'],
+    columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'created_at', 'url', 'has_media', 'media_urls'],
     func: async (page, kwargs) => {
         const listId = String(kwargs.listId || '').trim();
         if (!listId || !/^\d+$/.test(listId)) {
@@ -129,7 +132,11 @@ cli({
         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)');
-        const queryId = await page.evaluate(`async () => {
+        // opencli >=1.7.x wraps primitive page.evaluate returns as { session, data: <value> }.
+        // Without unwrap, the string queryId becomes "[object Object]" when interpolated into the URL,
+        // causing HTTP 400 "queryId may have expired".
+        const unwrap = (v) => (v && typeof v === 'object' && 'session' in v && 'data' in v ? v.data : v);
+        const queryIdRaw = await page.evaluate(`async () => {
             try {
                 const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
                 if (ghResp.ok) {
@@ -152,7 +159,8 @@ cli({
                 }
             } catch {}
             return null;
-        }`) || LIST_TWEETS_QUERY_ID;
+        }`);
+        const queryId = unwrap(queryIdRaw) || LIST_TWEETS_QUERY_ID;
         const headers = JSON.stringify({
             'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
             'X-Csrf-Token': ct0,
@@ -162,7 +170,8 @@ cli({
         const allTweets = [];
         const seen = new Set();
         let cursor = null;
-        for (let i = 0; i < 10 && allTweets.length < limit; i++) {
+        // 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);
             const apiUrl = buildUrl(queryId, listId, fetchCount, cursor);
             const data = await page.evaluate(`async () => {

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

@@ -30,9 +30,57 @@ describe('twitter list-tweets parser', () => {
             replies: 2,
             created_at: 'Wed Apr 16 10:00:00 +0000 2026',
             url: 'https://x.com/bob/status/99',
+            has_media: false,
+            media_urls: [],
         });
     });
 
+    it('includes photo media URLs from extended_entities', () => {
+        const tweet = extractTimelineTweet({
+            rest_id: '101',
+            legacy: {
+                full_text: 'pic post',
+                extended_entities: {
+                    media: [
+                        { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/abc.jpg' },
+                        { type: 'photo', media_url_https: 'https://pbs.twimg.com/media/def.jpg' },
+                    ],
+                },
+            },
+            core: { user_results: { result: { legacy: { screen_name: 'dave' } } } },
+        }, new Set());
+        expect(tweet?.has_media).toBe(true);
+        expect(tweet?.media_urls).toEqual([
+            'https://pbs.twimg.com/media/abc.jpg',
+            'https://pbs.twimg.com/media/def.jpg',
+        ]);
+    });
+
+    it('extracts mp4 variant URL for video media', () => {
+        const tweet = extractTimelineTweet({
+            rest_id: '102',
+            legacy: {
+                full_text: 'video post',
+                extended_entities: {
+                    media: [{
+                        type: 'video',
+                        media_url_https: 'https://pbs.twimg.com/amplify_video_thumb/thumb.jpg',
+                        video_info: {
+                            variants: [
+                                { content_type: 'application/x-mpegURL', url: 'https://video.twimg.com/playlist.m3u8' },
+                                { content_type: 'video/mp4', bitrate: 832000, url: 'https://video.twimg.com/low.mp4' },
+                                { content_type: 'video/mp4', bitrate: 2176000, url: 'https://video.twimg.com/high.mp4' },
+                            ],
+                        },
+                    }],
+                },
+            },
+            core: { user_results: { result: { legacy: { screen_name: 'erin' } } } },
+        }, new Set());
+        expect(tweet?.has_media).toBe(true);
+        expect(tweet?.media_urls?.[0]).toMatch(/\.mp4$/);
+    });
+
     it('prefers long-form note_tweet text over truncated legacy full_text', () => {
         const tweet = extractTimelineTweet({
             rest_id: '100',

package/clis/twitter/lists.js

@@ -103,7 +103,9 @@ export const command = cli({
         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)');
-        const queryId = await page.evaluate(`async () => {
+        // opencli >=1.7.x wraps primitive page.evaluate returns as { session, data: <value> }.
+        const unwrap = (v) => (v && typeof v === 'object' && 'session' in v && 'data' in v ? v.data : v);
+        const queryIdRaw = await page.evaluate(`async () => {
             try {
                 const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
                 if (ghResp.ok) {
@@ -126,7 +128,8 @@ export const command = cli({
                 }
             } catch {}
             return null;
-        }`) || LISTS_QUERY_ID;
+        }`);
+        const queryId = unwrap(queryIdRaw) || LISTS_QUERY_ID;
         const headers = JSON.stringify({
             'Authorization': `Bearer ${decodeURIComponent(TWITTER_BEARER_TOKEN)}`,
             'X-Csrf-Token': ct0,

package/clis/twitter/post.js

@@ -161,12 +161,25 @@ async function submitTweet(page, text) {
         const normalize = s => String(s || '').replace(/\u00a0/g, ' ').replace(/\s+/g, ' ').trim();
         const expectedText = normalize(expected);
         const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+        const statusUrl = (root = document) => {
+            const links = Array.from(root.querySelectorAll('a[href*="/status/"]'));
+            for (const link of links) {
+                const href = link.href || link.getAttribute('href') || '';
+                if (!href) continue;
+                try {
+                    const url = new URL(href, window.location.origin);
+                    const match = url.pathname.match(/^\\/(?:[^/]+|i)\\/status\\/(\\d+)/);
+                    if (match) return { url: url.href, id: match[1] };
+                } catch {}
+            }
+            return {};
+        };
         for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
             await new Promise(r => setTimeout(r, ${JSON.stringify(SUBMIT_POLL_MS)}));
             const toasts = Array.from(document.querySelectorAll('[role="alert"], [data-testid="toast"]'))
                 .filter((el) => visible(el));
             const successToast = toasts.find((el) => /sent|posted|your post was sent|your tweet was sent/i.test(el.textContent || ''));
-            if (successToast) return { ok: true, message: 'Tweet posted successfully.' };
+            if (successToast) return { ok: true, message: 'Tweet posted successfully.', ...statusUrl(successToast) };
             const alert = toasts.find((el) => /failed|error|try again|not sent|could not/i.test(el.textContent || ''));
             if (alert) return { ok: false, message: (alert.textContent || 'Tweet failed to post.').trim() };
 
@@ -175,7 +188,7 @@ async function submitTweet(page, text) {
             const hasMedia = !!document.querySelector('[data-testid="attachments"], [data-testid="tweetPhoto"]')
                 || document.querySelectorAll('img[src^="blob:"], video[src^="blob:"]').length > 0;
             if (!composerStillHasText && !hasMedia) {
-                return { ok: true, message: 'Tweet posted successfully.' };
+                return { ok: true, message: 'Tweet posted successfully.', ...statusUrl() };
             }
         }
         return { ok: false, message: 'Tweet submission did not complete before timeout.' };
@@ -194,7 +207,7 @@ cli({
         { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of the tweet' },
         { name: 'images', type: 'string', required: false, help: 'Image paths, comma-separated, max 4 (jpg/png/gif/webp)' },
     ],
-    columns: ['status', 'message', 'text'],
+    columns: ['status', 'message', 'text', 'id', 'url'],
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter post');
@@ -231,6 +244,12 @@ cli({
 
         await page.wait(1);
         const result = await submitTweet(page, text);
-        return [{ status: result?.ok ? 'success' : 'failed', message: result?.message ?? 'Tweet failed to post.', text }];
+        return [{
+            status: result?.ok ? 'success' : 'failed',
+            message: result?.message ?? 'Tweet failed to post.',
+            text,
+            ...(result?.id ? { id: result.id } : {}),
+            ...(result?.url ? { url: result.url } : {}),
+        }];
     }
 });

package/clis/twitter/post.test.js

@@ -46,6 +46,11 @@ function makePage(evaluateResults = [], overrides = {}) {
 describe('twitter post command', () => {
     const getCommand = () => getRegistry().get('twitter/post');
 
+    it('registers created tweet id/url columns', () => {
+        const command = getCommand();
+        expect(command?.columns).toEqual(['status', 'message', 'text', 'id', 'url']);
+    });
+
     it('posts text-only tweet successfully through the current compose route', async () => {
         const command = getCommand();
         const page = makePage([
@@ -63,6 +68,31 @@ describe('twitter post command', () => {
         expect(page.insertText).toHaveBeenCalledWith('hello world');
     });
 
+    it('returns the created tweet URL from the success toast when available', async () => {
+        const command = getCommand();
+        const page = makePage([
+            { ok: true },
+            { ok: true },
+            { ok: true },
+            {
+                ok: true,
+                message: 'Tweet posted successfully.',
+                id: '2054239044884693381',
+                url: 'https://x.com/darthjajaj6z/status/2054239044884693381',
+            },
+        ]);
+
+        const result = await command.func(page, { text: 'with url' });
+
+        expect(result).toEqual([{
+            status: 'success',
+            message: 'Tweet posted successfully.',
+            text: 'with url',
+            id: '2054239044884693381',
+            url: 'https://x.com/darthjajaj6z/status/2054239044884693381',
+        }]);
+    });
+
     it('returns failed when text area not found', async () => {
         const command = getCommand();
         const page = makePage([

package/clis/twitter/profile.js

@@ -1,6 +1,6 @@
-import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-import { resolveTwitterQueryId } from './shared.js';
+import { normalizeTwitterScreenName, resolveTwitterQueryId, unwrapBrowserResult } from './shared.js';
 import { TWITTER_BEARER_TOKEN } from './utils.js';
 const USER_BY_SCREEN_NAME_QUERY_ID = 'qRednkZG-rn1P6b48NINmQ';
 cli({
@@ -17,18 +17,26 @@ cli({
     ],
     columns: ['screen_name', 'name', 'bio', 'location', 'url', 'followers', 'following', 'tweets', 'likes', 'verified', 'created_at'],
     func: async (page, kwargs) => {
-        let username = (kwargs.username || '').replace(/^@/, '');
-        // If no username, detect the logged-in user
+        const rawUsername = String(kwargs.username ?? '').trim();
+        let username = normalizeTwitterScreenName(rawUsername);
+        if (rawUsername && !username) {
+            throw new ArgumentError('twitter profile username must be a valid Twitter/X handle', 'Example: opencli twitter profile @jack');
+        }
+        // If no username, detect the logged-in user.
+        // Bridge wraps primitive page.evaluate returns as { session, data:<value> };
+        // unwrap so the href string is usable downstream.
         if (!username) {
             await page.goto('https://x.com/home');
             await page.wait({ selector: '[data-testid="primaryColumn"]' });
-            const href = await page.evaluate(`() => {
+            const href = unwrapBrowserResult(await page.evaluate(`() => {
         const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
         return link ? link.getAttribute('href') : null;
-      }`);
-            if (!href)
+      }`));
+            if (!href || typeof href !== 'string')
+                throw new AuthRequiredError('x.com', 'Could not detect logged-in user. Are you logged in?');
+            username = normalizeTwitterScreenName(href);
+            if (!username)
                 throw new AuthRequiredError('x.com', 'Could not detect logged-in user. Are you logged in?');
-            username = href.replace('/', '');
         }
         // Navigate directly to the user's profile page (gives us cookie context)
         await page.goto(`https://x.com/${username}`);

package/clis/twitter/profile.test.js

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, AuthRequiredError } from '@jackwener/opencli/errors';
+import './profile.js';
+
+describe('twitter profile command', () => {
+    it('rejects invalid explicit usernames before navigation', async () => {
+        const command = getRegistry().get('twitter/profile');
+        const page = {
+            goto: vi.fn(),
+            wait: vi.fn(),
+            getCookies: vi.fn(),
+            evaluate: vi.fn(),
+        };
+
+        await expect(command.func(page, { username: 'viewer/extra' })).rejects.toBeInstanceOf(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.getCookies).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+
+    it('rejects route-like AppTabBar hrefs instead of navigating to that route profile', async () => {
+        const command = getRegistry().get('twitter/profile');
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            getCookies: vi.fn(),
+            evaluate: vi.fn(async (script) => {
+                if (String(script).includes('AppTabBar_Profile_Link')) return '/home';
+                throw new Error(`Unexpected evaluate: ${String(script).slice(0, 80)}`);
+            }),
+        };
+
+        await expect(command.func(page, {})).rejects.toBeInstanceOf(AuthRequiredError);
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/home');
+        expect(page.goto).toHaveBeenCalledTimes(1);
+        expect(page.getCookies).not.toHaveBeenCalled();
+    });
+});

package/clis/twitter/reply.js

@@ -10,6 +10,10 @@ import {
     resolveImagePath,
 } from './utils.js';
 
+const COMPOSER_SELECTOR = '[data-testid="tweetTextarea_0"]';
+const SUBMIT_POLL_MS = 500;
+const SUBMIT_TIMEOUT_MS = 15_000;
+
 function buildReplyComposerUrl(rawUrl) {
     // Replaces the legacy local extractTweetId which used `/\/status\/(\d+)/`
     // (silent: matched `/status/1234567` on substring `/status/123` and
@@ -19,7 +23,36 @@ function buildReplyComposerUrl(rawUrl) {
     return `https://x.com/compose/post?in_reply_to=${target.id}`;
 }
 
-async function submitReply(page, text) {
+function isPromiseCollectedError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return msg.includes('Promise was collected');
+}
+
+async function openReplyComposer(page, rawUrl) {
+    await page.goto(buildReplyComposerUrl(rawUrl), { waitUntil: 'load', settleMs: 2500 });
+    try {
+        await page.wait({ selector: COMPOSER_SELECTOR, timeout: 15 });
+        return { ok: true };
+    } catch {
+        // X sometimes leaves /compose/post?in_reply_to=<id> on the Home
+        // timeline behind a loading dialog. Fall back to the canonical tweet
+        // page and click the visible Reply action there.
+        await page.goto(rawUrl, { waitUntil: 'load', settleMs: 2500 });
+        const clicked = await page.evaluate(`(() => {
+            const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+            const buttons = Array.from(document.querySelectorAll('[data-testid="reply"]'));
+            const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
+            if (!btn) return { ok: false, message: 'Could not find the reply button on the target tweet.' };
+            btn.click();
+            return { ok: true };
+        })()`);
+        if (!clicked?.ok) return clicked;
+        await page.wait({ selector: COMPOSER_SELECTOR, timeout: 15 });
+        return { ok: true };
+    }
+}
+
+async function insertReplyText(page, text) {
     return page.evaluate(`(async () => {
       try {
           const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
@@ -44,23 +77,109 @@ async function submitReply(page, text) {
           }
 
           await new Promise(r => setTimeout(r, 1000));
+          const normalize = s => String(s || '').replace(/\\u00a0/g, ' ').replace(/\\s+/g, ' ').trim();
+          const actual = box.innerText || box.textContent || '';
+          if (!normalize(actual).includes(normalize(textToInsert))) {
+              return { ok: false, message: 'Could not verify reply text in the composer after typing.', actualText: actual };
+          }
+          return { ok: true };
+      } catch (e) {
+          return { ok: false, message: e.toString() };
+      }
+  })()`);
+}
 
+async function clickReplyButton(page) {
+    return page.evaluate(`(() => {
+      try {
+          const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
           const buttons = Array.from(
               document.querySelectorAll('[data-testid="tweetButton"], [data-testid="tweetButtonInline"]')
           );
-          const btn = buttons.find((el) => visible(el) && !el.disabled);
+          const btn = buttons.find((el) => visible(el) && !el.disabled && el.getAttribute('aria-disabled') !== 'true');
           if (!btn) {
               return { ok: false, message: 'Reply button is disabled or not found.' };
           }
 
           btn.click();
-          return { ok: true, message: 'Reply posted successfully.' };
+          return { ok: true };
       } catch (e) {
           return { ok: false, message: e.toString() };
       }
   })()`);
 }
 
+async function detectReplySent(page) {
+    return page.evaluate(`(() => {
+        const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+        const toasts = Array.from(document.querySelectorAll('[role="alert"], [data-testid="toast"]'))
+            .filter((el) => visible(el));
+        const successToast = toasts.find((el) => /sent|posted|your post was sent|your tweet was sent/i.test(el.textContent || ''));
+        if (!successToast) return { ok: false };
+        const link = successToast.querySelector('a[href*="/status/"]');
+        return {
+            ok: true,
+            message: 'Reply posted successfully.',
+            url: link?.href || link?.getAttribute('href') || undefined
+        };
+    })()`);
+}
+
+async function waitForReplySent(page, text) {
+    const iterations = Math.ceil(SUBMIT_TIMEOUT_MS / SUBMIT_POLL_MS);
+    try {
+        return await page.evaluate(`(async () => {
+            const expected = ${JSON.stringify(text)};
+            const normalize = s => String(s || '').replace(/\\u00a0/g, ' ').replace(/\\s+/g, ' ').trim();
+            const expectedText = normalize(expected);
+            const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+            for (let i = 0; i < ${JSON.stringify(iterations)}; i++) {
+                await new Promise(r => setTimeout(r, ${JSON.stringify(SUBMIT_POLL_MS)}));
+                const toasts = Array.from(document.querySelectorAll('[role="alert"], [data-testid="toast"]'))
+                    .filter((el) => visible(el));
+                const successToast = toasts.find((el) => /sent|posted|your post was sent|your tweet was sent/i.test(el.textContent || ''));
+                if (successToast) {
+                    const link = successToast.querySelector('a[href*="/status/"]');
+                    return {
+                        ok: true,
+                        message: 'Reply posted successfully.',
+                        url: link?.href || link?.getAttribute('href') || undefined
+                    };
+                }
+                const alert = toasts.find((el) => /failed|error|try again|not sent|could not/i.test(el.textContent || ''));
+                if (alert) return { ok: false, message: (alert.textContent || 'Reply failed to post.').trim() };
+
+                const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]')).filter(visible);
+                const composerStillHasText = boxes.some((box) => normalize(box.innerText || box.textContent || '').includes(expectedText));
+                if (!composerStillHasText) return { ok: true, message: 'Reply posted successfully.' };
+            }
+            return { ok: false, message: 'Reply submission did not complete before timeout.' };
+        })()`);
+    } catch (err) {
+        // X may route the SPA immediately after click, making CDP collect the
+        // polling promise even though the reply was submitted. If the page now
+        // shows the success toast, report success instead of a false negative.
+        if (!isPromiseCollectedError(err)) throw err;
+        await page.wait(2);
+        const recovered = await detectReplySent(page);
+        if (recovered?.ok) return recovered;
+        throw err;
+    }
+}
+
+async function submitReply(page, text) {
+    const typed = await insertReplyText(page, text);
+    if (!typed?.ok) return typed;
+    let clicked;
+    try {
+        clicked = await clickReplyButton(page);
+    } catch (err) {
+        if (!isPromiseCollectedError(err)) throw err;
+    }
+    if (clicked && !clicked.ok) return clicked;
+    return waitForReplySent(page, text);
+}
+
 cli({
     site: 'twitter',
     name: 'reply',
@@ -75,7 +194,7 @@ cli({
         { name: 'image', help: 'Optional local image path to attach to the reply' },
         { name: 'image-url', help: 'Optional remote image URL to download and attach to the reply' },
     ],
-    columns: ['status', 'message', 'text'],
+    columns: ['status', 'message', 'text', 'url'],
     func: async (page, kwargs) => {
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter reply');
@@ -92,21 +211,24 @@ cli({
                 localImagePath = downloaded.absPath;
                 cleanupDir = downloaded.cleanupDir;
             }
-            // Dedicated composer is more reliable than the inline tweet page reply box.
-            await page.goto(buildReplyComposerUrl(kwargs.url), { waitUntil: 'load', settleMs: 2500 });
-            await page.wait({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+            // Dedicated composer is normally more reliable than the inline
+            // tweet page reply box, but X occasionally leaves that route on the
+            // Home timeline behind a loading dialog. openReplyComposer falls
+            // back to the target tweet's visible Reply action.
+            const composer = await openReplyComposer(page, kwargs.url);
+            if (!composer?.ok) {
+                return [{ status: 'failed', message: composer?.message ?? 'Could not open the reply composer.', text: kwargs.text }];
+            }
             if (localImagePath) {
                 await page.wait({ selector: COMPOSER_FILE_INPUT_SELECTOR, timeout: 20 });
                 await attachComposerImage(page, localImagePath);
             }
             const result = await submitReply(page, kwargs.text);
-            if (result.ok) {
-                await page.wait(3); // Wait for network submission to complete
-            }
             return [{
                     status: result.ok ? 'success' : 'failed',
                     message: result.message,
                     text: kwargs.text,
+                    ...(result.url ? { url: result.url } : {}),
                     ...(kwargs.image ? { image: kwargs.image } : {}),
                     ...(kwargs['image-url'] ? { 'image-url': kwargs['image-url'] } : {}),
                 }];
@@ -119,4 +241,5 @@ cli({
 });
 export const __test__ = {
     buildReplyComposerUrl,
+    isPromiseCollectedError,
 };