@jackwener/opencli 1.7.13 → 1.7.15

package/clis/twitter/quote.test.js

@@ -0,0 +1,194 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { __test__ } from './quote.js';
+import './quote.js';
+import { createPageMock } from '../test-utils.js';
+
+describe('twitter quote helpers', () => {
+    it('builds the quote composer URL with the source tweet attached as ?url=...', () => {
+        const composeUrl = __test__.buildQuoteComposerUrl('https://x.com/alice/status/2040254679301718161?s=20');
+        // The full source URL is round-tripped via encodeURIComponent — decoding it
+        // back must yield the original URL. This guards against accidental drops of
+        // query parameters or fragment characters in future refactors.
+        const parsed = new URL(composeUrl);
+        expect(parsed.origin + parsed.pathname).toBe('https://x.com/compose/post');
+        expect(parsed.searchParams.get('url')).toBe('https://x.com/alice/status/2040254679301718161?s=20');
+    });
+
+    it('rejects malformed URLs before any browser interaction', () => {
+        expect(() => __test__.buildQuoteComposerUrl('https://x.com/alice/home')).toThrow(/Could not extract tweet ID/);
+        expect(() => __test__.buildQuoteComposerUrl('not a url')).toThrow(/Invalid tweet URL/);
+        expect(() => __test__.buildQuoteComposerUrl('https://evil.com/?next=https://x.com/alice/status/2040254679301718161')).toThrow(ArgumentError);
+    });
+});
+
+describe('twitter quote command', () => {
+    it('navigates to the quote composer and reports success when the script confirms', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: true, message: 'Quote tweet posted successfully.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'great take',
+        });
+        expect(page.goto).toHaveBeenCalledWith(
+            'https://x.com/compose/post?url=https%3A%2F%2Fx.com%2Falice%2Fstatus%2F2040254679301718161',
+            { waitUntil: 'load', settleMs: 2500 },
+        );
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+        expect(page.wait).toHaveBeenNthCalledWith(2, 3);
+        const script = page.evaluate.mock.calls[0][0];
+        // Quote-attachment guard: the script must verify the quoted card rendered
+        // before submitting; otherwise we'd silently post a plain tweet without
+        // the quote attachment. Detection now uses the shared helper's
+        // __twHasLinkToTarget(document) — JSDOM coverage in shared.test.js
+        // proves it does an exact (not substring) match on the status id.
+        expect(script).toContain('Quote target did not render');
+        expect(script).toContain('document.execCommand');
+        expect(script).toContain('tweetButton');
+        expect(script).toContain('__twHasLinkToTarget(document)');
+        expect(script).toContain('__twGetStatusIdFromHref');
+        expect(script).toContain('Quote tweet submission did not complete before timeout');
+        expect(script).toContain('[role="alert"], [data-testid="toast"]');
+        expect(result).toEqual([
+            {
+                status: 'success',
+                message: 'Quote tweet posted successfully.',
+                text: 'great take',
+            },
+        ]);
+    });
+
+    it('uploads a local image through the quote composer when --image is provided', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        expect(cmd?.func).toBeTypeOf('function');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-twitter-quote-'));
+        const imagePath = path.join(tempDir, 'banner.png');
+        fs.writeFileSync(imagePath, Buffer.from([0x89, 0x50, 0x4e, 0x47]));
+        const setFileInput = vi.fn().mockResolvedValue(undefined);
+        const page = createPageMock([
+            { ok: true, previewCount: 1 },
+            { ok: true, message: 'Quote tweet posted successfully.' },
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'check this',
+            image: imagePath,
+        });
+        expect(page.goto).toHaveBeenCalledWith(
+            'https://x.com/compose/post?url=https%3A%2F%2Fx.com%2Falice%2Fstatus%2F2040254679301718161',
+            { waitUntil: 'load', settleMs: 2500 },
+        );
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+        expect(page.wait).toHaveBeenNthCalledWith(2, { selector: 'input[type="file"][data-testid="fileInput"]', timeout: 20 });
+        expect(setFileInput).toHaveBeenCalledWith([imagePath], 'input[type="file"][data-testid="fileInput"]');
+        expect(result).toEqual([
+            {
+                status: 'success',
+                message: 'Quote tweet posted successfully.',
+                text: 'check this',
+                image: imagePath,
+            },
+        ]);
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    it('downloads a remote image before uploading when --image-url is provided', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        expect(cmd?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            headers: {
+                get: vi.fn().mockReturnValue('image/png'),
+            },
+            arrayBuffer: vi.fn().mockResolvedValue(Uint8Array.from([0x89, 0x50, 0x4e, 0x47]).buffer),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const setFileInput = vi.fn().mockResolvedValue(undefined);
+        const page = createPageMock([
+            { ok: true, previewCount: 1 },
+            { ok: true, message: 'Quote tweet posted successfully.' },
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'remote attach',
+            'image-url': 'https://example.com/banner',
+        });
+        expect(fetchMock).toHaveBeenCalledWith('https://example.com/banner');
+        expect(setFileInput).toHaveBeenCalledTimes(1);
+        const uploadedPath = setFileInput.mock.calls[0][0][0];
+        expect(uploadedPath).toMatch(/opencli-twitter-.*\/image\.png$/);
+        // Per-call tmp dir is removed in the adapter's finally block.
+        expect(fs.existsSync(uploadedPath)).toBe(false);
+        expect(result).toEqual([
+            {
+                status: 'success',
+                message: 'Quote tweet posted successfully.',
+                text: 'remote attach',
+                'image-url': 'https://example.com/banner',
+            },
+        ]);
+        vi.unstubAllGlobals();
+    });
+
+    it('rejects using --image and --image-url together', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'nope',
+            image: '/tmp/a.png',
+            'image-url': 'https://example.com/a.png',
+        })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('returns a failed row when the quote target fails to render', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: false, message: 'Quote target did not render in the composer. The source tweet may be deleted or restricted.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'orphaned quote',
+        });
+        expect(result).toEqual([
+            {
+                status: 'failed',
+                message: 'Quote target did not render in the composer. The source tweet may be deleted or restricted.',
+                text: 'orphaned quote',
+            },
+        ]);
+        // Only the textarea wait should run when ok is false (no extra 3s post-submit wait).
+        expect(page.wait).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws CommandExecutionError when no page is provided', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        await expect(cmd.func(undefined, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+            text: 'hi',
+        })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('rejects invalid tweet URLs before navigation', async () => {
+        const cmd = getRegistry().get('twitter/quote');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'https://x.com.evil.com/alice/status/2040254679301718161',
+            text: 'hi',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+});

package/clis/twitter/reply.js

@@ -1,174 +1,24 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import * as os from 'node:os';
 import { CommandExecutionError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
-const REPLY_FILE_INPUT_SELECTOR = 'input[type="file"][data-testid="fileInput"]';
-const SUPPORTED_IMAGE_EXTENSIONS = new Set([
-    '.jpg',
-    '.jpeg',
-    '.png',
-    '.gif',
-    '.webp',
-]);
-const MAX_IMAGE_SIZE_BYTES = 20 * 1024 * 1024; // 20 MB (Twitter allows 5MB images, 15MB GIFs)
-const CONTENT_TYPE_TO_EXTENSION = {
-    'image/jpeg': '.jpg',
-    'image/jpg': '.jpg',
-    'image/png': '.png',
-    'image/gif': '.gif',
-    'image/webp': '.webp',
-};
-function resolveImagePath(imagePath) {
-    const absPath = path.resolve(imagePath);
-    if (!fs.existsSync(absPath)) {
-        throw new Error(`Image file not found: ${absPath}`);
-    }
-    const ext = path.extname(absPath).toLowerCase();
-    if (!SUPPORTED_IMAGE_EXTENSIONS.has(ext)) {
-        throw new Error(`Unsupported image format "${ext}". Supported: jpg, jpeg, png, gif, webp`);
-    }
-    const stat = fs.statSync(absPath);
-    if (stat.size > MAX_IMAGE_SIZE_BYTES) {
-        throw new Error(`Image too large: ${(stat.size / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
-    }
-    return absPath;
-}
-function extractTweetId(url) {
-    let pathname = '';
-    try {
-        pathname = new URL(url).pathname;
-    }
-    catch {
-        throw new Error(`Invalid tweet URL: ${url}`);
-    }
-    const match = pathname.match(/\/status\/(\d+)/);
-    if (!match?.[1]) {
-        throw new Error(`Could not extract tweet ID from URL: ${url}`);
-    }
-    return match[1];
-}
-function buildReplyComposerUrl(url) {
-    return `https://x.com/compose/post?in_reply_to=${extractTweetId(url)}`;
-}
-function resolveImageExtension(url, contentType) {
-    const normalizedContentType = (contentType || '').split(';')[0].trim().toLowerCase();
-    if (normalizedContentType && CONTENT_TYPE_TO_EXTENSION[normalizedContentType]) {
-        return CONTENT_TYPE_TO_EXTENSION[normalizedContentType];
-    }
-    try {
-        const pathname = new URL(url).pathname;
-        const ext = path.extname(pathname).toLowerCase();
-        if (SUPPORTED_IMAGE_EXTENSIONS.has(ext))
-            return ext;
-    }
-    catch {
-        // Fall through to the final error below.
-    }
-    throw new Error(`Unsupported remote image format "${normalizedContentType || 'unknown'}". ` +
-        'Supported: jpg, jpeg, png, gif, webp');
-}
-async function downloadRemoteImage(imageUrl) {
-    let parsed;
-    try {
-        parsed = new URL(imageUrl);
-    }
-    catch {
-        throw new Error(`Invalid image URL: ${imageUrl}`);
-    }
-    if (!/^https?:$/.test(parsed.protocol)) {
-        throw new Error(`Unsupported image URL protocol: ${parsed.protocol}`);
-    }
-    const response = await fetch(imageUrl);
-    if (!response.ok) {
-        throw new Error(`Image download failed: HTTP ${response.status}`);
-    }
-    const contentLength = Number(response.headers.get('content-length') || '0');
-    if (contentLength > MAX_IMAGE_SIZE_BYTES) {
-        throw new Error(`Image too large: ${(contentLength / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
-    }
-    const ext = resolveImageExtension(imageUrl, response.headers.get('content-type'));
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-twitter-reply-'));
-    const tmpPath = path.join(tmpDir, `image${ext}`);
-    const buffer = Buffer.from(await response.arrayBuffer());
-    if (buffer.byteLength > MAX_IMAGE_SIZE_BYTES) {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-        throw new Error(`Image too large: ${(buffer.byteLength / 1024 / 1024).toFixed(1)} MB (max ${MAX_IMAGE_SIZE_BYTES / 1024 / 1024} MB)`);
-    }
-    fs.writeFileSync(tmpPath, buffer);
-    return tmpPath;
-}
-async function attachReplyImage(page, absImagePath) {
-    let uploaded = false;
-    if (page.setFileInput) {
-        try {
-            await page.setFileInput([absImagePath], REPLY_FILE_INPUT_SELECTOR);
-            uploaded = true;
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes('Unknown action') && !msg.includes('not supported')) {
-                throw new Error(`Image upload failed: ${msg}`);
-            }
-            // setFileInput not supported by extension — fall through to base64 fallback
-        }
-    }
-    if (!uploaded) {
-        const ext = path.extname(absImagePath).toLowerCase();
-        const mimeType = ext === '.png'
-            ? 'image/png'
-            : ext === '.gif'
-                ? 'image/gif'
-                : ext === '.webp'
-                    ? 'image/webp'
-                    : 'image/jpeg';
-        const base64 = fs.readFileSync(absImagePath).toString('base64');
-        if (base64.length > 500_000) {
-            console.warn(`[warn] Image base64 payload is ${(base64.length / 1024 / 1024).toFixed(1)}MB. ` +
-                'This may fail with the browser bridge. Update the extension to v1.6+ for CDP-based upload, ' +
-                'or compress the image before attaching.');
-        }
-        const upload = await page.evaluate(`
-      (() => {
-        const input = document.querySelector(${JSON.stringify(REPLY_FILE_INPUT_SELECTOR)});
-        if (!input) return { ok: false, error: 'No file input found on page' };
-
-        const binary = atob(${JSON.stringify(base64)});
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-
-        const dt = new DataTransfer();
-        const blob = new Blob([bytes], { type: ${JSON.stringify(mimeType)} });
-        dt.items.add(new File([blob], ${JSON.stringify(path.basename(absImagePath))}, { type: ${JSON.stringify(mimeType)} }));
+import { parseTweetUrl } from './shared.js';
+import {
+    COMPOSER_FILE_INPUT_SELECTOR,
+    attachComposerImage,
+    downloadRemoteImage,
+    resolveImagePath,
+} from './utils.js';
 
-        Object.defineProperty(input, 'files', { value: dt.files, writable: false });
-        input.dispatchEvent(new Event('change', { bubbles: true }));
-        input.dispatchEvent(new Event('input', { bubbles: true }));
-        return { ok: true };
-      })()
-    `);
-        if (!upload?.ok) {
-            throw new Error(`Image upload failed: ${upload?.error ?? 'unknown error'}`);
-        }
-    }
-    await page.wait(2);
-    const uploadState = await page.evaluate(`
-    (() => {
-      const previewCount = document.querySelectorAll(
-        '[data-testid="attachments"] img, [data-testid="attachments"] video, [data-testid="tweetPhoto"]'
-      ).length;
-      const hasMedia = previewCount > 0
-        || !!document.querySelector('[data-testid="attachments"]')
-        || !!Array.from(document.querySelectorAll('button,[role="button"]')).find((el) =>
-          /remove media|remove image|remove/i.test((el.getAttribute('aria-label') || '') + ' ' + (el.textContent || ''))
-        );
-      return { ok: hasMedia, previewCount };
-    })()
-  `);
-    if (!uploadState?.ok) {
-        throw new Error('Image upload failed: preview did not appear.');
-    }
+function buildReplyComposerUrl(rawUrl) {
+    // Replaces the legacy local extractTweetId which used `/\/status\/(\d+)/`
+    // (silent: matched `/status/1234567` on substring `/status/123` and
+    // accepted any host). parseTweetUrl bubbles ArgumentError on
+    // malformed/off-domain inputs.
+    const target = parseTweetUrl(rawUrl);
+    return `https://x.com/compose/post?in_reply_to=${target.id}`;
 }
+
 async function submitReply(page, text) {
     return page.evaluate(`(async () => {
       try {
@@ -210,6 +60,7 @@ async function submitReply(page, text) {
       }
   })()`);
 }
+
 cli({
     site: 'twitter',
     name: 'reply',
@@ -229,24 +80,24 @@ cli({
         if (!page)
             throw new CommandExecutionError('Browser session required for twitter reply');
         if (kwargs.image && kwargs['image-url']) {
-            throw new Error('Use either --image or --image-url, not both.');
+            throw new CommandExecutionError('Use either --image or --image-url, not both.');
         }
         let localImagePath;
         let cleanupDir;
         try {
             if (kwargs.image) {
                 localImagePath = resolveImagePath(kwargs.image);
-            }
-            else if (kwargs['image-url']) {
-                localImagePath = await downloadRemoteImage(kwargs['image-url']);
-                cleanupDir = path.dirname(localImagePath);
+            } else if (kwargs['image-url']) {
+                const downloaded = await downloadRemoteImage(kwargs['image-url']);
+                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 });
             if (localImagePath) {
-                await page.wait({ selector: REPLY_FILE_INPUT_SELECTOR, timeout: 20 });
-                await attachReplyImage(page, 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) {
@@ -259,8 +110,7 @@ cli({
                     ...(kwargs.image ? { image: kwargs.image } : {}),
                     ...(kwargs['image-url'] ? { 'image-url': kwargs['image-url'] } : {}),
                 }];
-        }
-        finally {
+        } finally {
             if (cleanupDir) {
                 fs.rmSync(cleanupDir, { recursive: true, force: true });
             }
@@ -269,8 +119,4 @@ cli({
 });
 export const __test__ = {
     buildReplyComposerUrl,
-    downloadRemoteImage,
-    extractTweetId,
-    resolveImageExtension,
-    resolveImagePath,
 };

package/clis/twitter/reply.test.js

@@ -2,9 +2,12 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './reply.js';
+import { __test__ as utilsTest } from './utils.js';
 import { createPageMock } from '../test-utils.js';
+
 describe('twitter reply command', () => {
     it('uses the dedicated reply composer for text-only replies too', async () => {
         const cmd = getRegistry().get('twitter/reply');
@@ -83,7 +86,11 @@ describe('twitter reply command', () => {
         expect(fetchMock).toHaveBeenCalledWith('https://example.com/qr');
         expect(setFileInput).toHaveBeenCalledTimes(1);
         const uploadedPath = setFileInput.mock.calls[0][0][0];
-        expect(uploadedPath).toMatch(/opencli-twitter-reply-.*\/image\.png$/);
+        // Tmp dir is created by utils.downloadRemoteImage with the
+        // 'opencli-twitter-' prefix; final extension comes from Content-Type.
+        expect(uploadedPath).toMatch(/opencli-twitter-.*\/image\.png$/);
+        // Per-call tmp dir is removed in the adapter's finally block, so the
+        // downloaded file no longer exists once the command returns.
         expect(fs.existsSync(uploadedPath)).toBe(false);
         expect(result).toEqual([
             {
@@ -95,10 +102,6 @@ describe('twitter reply command', () => {
         ]);
         vi.unstubAllGlobals();
     });
-    it('rejects invalid image paths early', async () => {
-        await expect(() => __test__.resolveImagePath('/tmp/does-not-exist.png'))
-            .toThrow('Image file not found');
-    });
     it('rejects using --image and --image-url together', async () => {
         const cmd = getRegistry().get('twitter/reply');
         expect(cmd?.func).toBeTypeOf('function');
@@ -108,16 +111,31 @@ describe('twitter reply command', () => {
             text: 'nope',
             image: '/tmp/a.png',
             'image-url': 'https://example.com/a.png',
-        })).rejects.toThrow('Use either --image or --image-url, not both.');
+        })).rejects.toThrow(CommandExecutionError);
+    });
+    it('rejects malformed tweet URLs before any browser interaction', () => {
+        // buildReplyComposerUrl runs parseTweetUrl synchronously; substring matches
+        // and off-domain hosts now throw ArgumentError instead of silently
+        // producing a wrong-host /compose/post URL.
+        expect(() => __test__.buildReplyComposerUrl('https://x.com/alice/home')).toThrow(ArgumentError);
+        expect(() => __test__.buildReplyComposerUrl('https://x.com.evil.com/alice/status/2040254679301718161')).toThrow(ArgumentError);
+        expect(() => __test__.buildReplyComposerUrl('not a url')).toThrow(ArgumentError);
     });
-    it('extracts tweet ids from both user and i/status URLs', () => {
-        expect(__test__.extractTweetId('https://x.com/_kop6/status/2040254679301718161?s=20')).toBe('2040254679301718161');
-        expect(__test__.extractTweetId('https://x.com/i/status/2040318731105313143')).toBe('2040318731105313143');
+    it('builds the reply composer URL for both /<user>/status/<id> and /i/status/<id> shapes', () => {
+        expect(__test__.buildReplyComposerUrl('https://x.com/_kop6/status/2040254679301718161?s=20'))
+            .toBe('https://x.com/compose/post?in_reply_to=2040254679301718161');
         expect(__test__.buildReplyComposerUrl('https://x.com/i/status/2040318731105313143'))
             .toBe('https://x.com/compose/post?in_reply_to=2040318731105313143');
     });
+});
+
+describe('twitter image helpers (utils.js)', () => {
+    it('rejects invalid image paths early', () => {
+        expect(() => utilsTest.resolveImagePath('/tmp/does-not-exist.png'))
+            .toThrow(ArgumentError);
+    });
     it('prefers content-type when resolving remote image extensions', () => {
-        expect(__test__.resolveImageExtension('https://example.com/no-ext', 'image/webp')).toBe('.webp');
-        expect(__test__.resolveImageExtension('https://example.com/a.jpeg?x=1', null)).toBe('.jpeg');
+        expect(utilsTest.resolveImageExtension('https://example.com/no-ext', 'image/webp')).toBe('.webp');
+        expect(utilsTest.resolveImageExtension('https://example.com/a.jpeg?x=1', null)).toBe('.jpeg');
     });
 });

package/clis/twitter/retweet.js

@@ -0,0 +1,94 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl, buildTwitterArticleScopeSource } from './shared.js';
+
+cli({
+    site: 'twitter',
+    name: 'retweet',
+    access: 'write',
+    description: 'Retweet a specific tweet',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to retweet' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter retweet');
+        const target = parseTweetUrl(kwargs.url);
+        await page.goto(target.url);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        const result = await page.evaluate(`(async () => {
+        try {
+            ${buildTwitterArticleScopeSource(target.id)}
+            // Poll for the tweet to render. State probes scoped to the article
+            // matching the requested status id — bare querySelector on a
+            // conversation page would silently grab the first article (e.g.
+            // the parent tweet) and retweet the wrong one.
+            let attempts = 0;
+            let retweetBtn = null;
+            let unretweetBtn = null;
+            let targetArticle = null;
+
+            while (attempts < 20) {
+                targetArticle = findTargetArticle();
+                unretweetBtn = targetArticle?.querySelector('[data-testid="unretweet"]') || null;
+                retweetBtn = targetArticle?.querySelector('[data-testid="retweet"]') || null;
+
+                if (unretweetBtn || retweetBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            // Already retweeted: idempotent success
+            if (unretweetBtn) {
+                return { ok: true, message: 'Tweet is already retweeted.' };
+            }
+
+            if (!retweetBtn) {
+                return { ok: false, message: 'Could not find the Retweet button on this tweet after waiting 10 seconds. Are you logged in?' };
+            }
+
+            // Step 1: click Retweet button → opens menu
+            retweetBtn.click();
+
+            // Step 2: wait for and click the confirm menu item. The confirm
+            // popover renders at the document root, not inside the article,
+            // so this lookup is intentionally document-scoped.
+            let confirmBtn = null;
+            for (let i = 0; i < 20; i++) {
+                await new Promise(r => setTimeout(r, 250));
+                confirmBtn = document.querySelector('[data-testid="retweetConfirm"]');
+                if (confirmBtn) break;
+            }
+            if (!confirmBtn) {
+                return { ok: false, message: 'Retweet menu opened but the confirm option did not appear.' };
+            }
+            confirmBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Verify success by checking if the 'unretweet' button appeared
+            const verifyArticle = findTargetArticle() || targetArticle;
+            const verifyBtn = verifyArticle?.querySelector('[data-testid="unretweet"]');
+            if (verifyBtn) {
+                return { ok: true, message: 'Tweet successfully retweeted.' };
+            } else {
+                return { ok: false, message: 'Retweet action was initiated but UI did not update as expected.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the retweet network request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});