@jackwener/opencli 1.7.17 → 1.7.19

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,
 };

package/clis/twitter/reply.test.js

@@ -13,6 +13,8 @@ describe('twitter reply command', () => {
         const cmd = getRegistry().get('twitter/reply');
         expect(cmd?.func).toBeTypeOf('function');
         const page = createPageMock([
+            { ok: true },
+            { ok: true },
             { ok: true, message: 'Reply posted successfully.' },
         ]);
         const result = await cmd.func(page, {
@@ -38,6 +40,8 @@ describe('twitter reply command', () => {
         const setFileInput = vi.fn().mockResolvedValue(undefined);
         const page = createPageMock([
             { ok: true, previewCount: 1 },
+            { ok: true },
+            { ok: true },
             { ok: true, message: 'Reply posted successfully.' },
         ], {
             setFileInput,
@@ -74,6 +78,8 @@ describe('twitter reply command', () => {
         const setFileInput = vi.fn().mockResolvedValue(undefined);
         const page = createPageMock([
             { ok: true, previewCount: 1 },
+            { ok: true },
+            { ok: true },
             { ok: true, message: 'Reply posted successfully.' },
         ], {
             setFileInput,
@@ -102,6 +108,55 @@ describe('twitter reply command', () => {
         ]);
         vi.unstubAllGlobals();
     });
+    it('falls back to the target tweet page when the dedicated composer route does not expose a textarea', async () => {
+        const cmd = getRegistry().get('twitter/reply');
+        expect(cmd?.func).toBeTypeOf('function');
+        const wait = vi.fn()
+            .mockRejectedValueOnce(new Error('Selector not found: [data-testid="tweetTextarea_0"]'))
+            .mockResolvedValue(undefined);
+        const page = createPageMock([
+            { ok: true }, // click target tweet page Reply button
+            { ok: true }, // insert reply text
+            { ok: true }, // click composer Reply button
+            { ok: true, message: 'Reply posted successfully.' }, // submit completed
+        ], { wait });
+
+        const url = 'https://x.com/_kop6/status/2040254679301718161?s=20';
+        const result = await cmd.func(page, { url, text: 'fallback reply' });
+
+        expect(page.goto).toHaveBeenNthCalledWith(1, 'https://x.com/compose/post?in_reply_to=2040254679301718161', { waitUntil: 'load', settleMs: 2500 });
+        expect(page.goto).toHaveBeenNthCalledWith(2, url, { waitUntil: 'load', settleMs: 2500 });
+        expect(page.evaluate.mock.calls[0][0]).toContain('[data-testid="reply"]');
+        expect(wait).toHaveBeenLastCalledWith({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+        expect(result).toEqual([{ status: 'success', message: 'Reply posted successfully.', text: 'fallback reply' }]);
+    });
+    it('treats an X success toast as success after a Promise was collected error', async () => {
+        const cmd = getRegistry().get('twitter/reply');
+        expect(cmd?.func).toBeTypeOf('function');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce({ ok: true }) // insert reply text
+            .mockResolvedValueOnce({ ok: true }) // click Reply
+            .mockRejectedValueOnce(new Error('{"code":-32000,"message":"Promise was collected"}'))
+            .mockResolvedValueOnce({
+                ok: true,
+                message: 'Reply posted successfully.',
+                url: 'https://x.com/me/status/123',
+            });
+        const page = createPageMock([], { evaluate });
+
+        const result = await cmd.func(page, {
+            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
+            text: 'toast recovery',
+        });
+
+        expect(page.wait).toHaveBeenCalledWith(2);
+        expect(result).toEqual([{
+            status: 'success',
+            message: 'Reply posted successfully.',
+            text: 'toast recovery',
+            url: 'https://x.com/me/status/123',
+        }]);
+    });
     it('rejects using --image and --image-url together', async () => {
         const cmd = getRegistry().get('twitter/reply');
         expect(cmd?.func).toBeTypeOf('function');