@jackwener/opencli 1.7.12 → 1.7.14

package/clis/tvmaze/tvmaze.test.js

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import './search.js';
+import './show.js';
+
+afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+});
+
+describe('tvmaze search adapter', () => {
+    const cmd = getRegistry().get('tvmaze/search');
+
+    it('rejects empty query and bad limit before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ query: '', limit: 5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ query: 'foo', limit: 100 })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 429 to CommandExecutionError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
+        await expect(cmd.func({ query: 'foo', limit: 5 })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when no shows match', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('[]', { status: 200 })));
+        await expect(cmd.func({ query: 'asdfghjkl', limit: 5 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('strips HTML from summary and ids round-trip into tvmaze show <id>', async () => {
+        const list = [{
+            score: 1.2,
+            show: {
+                id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English',
+                genres: ['Drama'], status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11',
+                network: { name: 'AMC' }, rating: { average: 9.2 },
+                summary: '<p><b>Breaking Bad</b> is a show with &amp; entities &#39;here&#39;, &#x27;hex&#x27;, and &hellip;.</p>',
+                url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+            },
+        }];
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(list), { status: 200 })));
+
+        const rows = await cmd.func({ query: 'breaking bad', limit: 5 });
+        expect(rows[0]).toMatchObject({
+            rank: 1, id: 169, name: 'Breaking Bad', network: 'AMC', rating: 9.2, matchScore: 1.2,
+        });
+        expect(rows[0].summary).toBe("Breaking Bad is a show with & entities 'here', 'hex', and ….");
+        // id round-trip
+        expect(typeof rows[0].id).toBe('number');
+    });
+});
+
+describe('tvmaze show adapter', () => {
+    const cmd = getRegistry().get('tvmaze/show');
+
+    it('rejects non-positive id before fetching', async () => {
+        const fetchMock = vi.fn();
+        vi.stubGlobal('fetch', fetchMock);
+
+        await expect(cmd.func({ id: 0 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: -5 })).rejects.toThrow(ArgumentError);
+        await expect(cmd.func({ id: 'abc' })).rejects.toThrow(ArgumentError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('maps HTTP 404 to EmptyResultError', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
+        await expect(cmd.func({ id: 99999999 })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('returns full show detail with externals + schedule', async () => {
+        const show = {
+            id: 169, name: 'Breaking Bad', type: 'Scripted', language: 'English', genres: ['Drama'],
+            status: 'Ended', premiered: '2008-01-20', ended: '2019-10-11', runtime: 60, averageRuntime: 60,
+            network: { name: 'AMC', country: { name: 'United States' } }, schedule: { time: '22:00', days: ['Sunday'] },
+            rating: { average: 9.2 }, externals: { imdb: 'tt0903747', thetvdb: 81189 },
+            officialSite: 'http://www.amc.com/shows/breaking-bad',
+            summary: '<p>Plain.</p>', url: 'https://www.tvmaze.com/shows/169/breaking-bad',
+        };
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(show), { status: 200 })));
+
+        const rows = await cmd.func({ id: 169 });
+        expect(rows[0]).toMatchObject({
+            id: 169, name: 'Breaking Bad', country: 'United States', schedule: 'Sunday 22:00',
+            imdb: 'tt0903747', thetvdb: 81189, rating: 9.2, summary: 'Plain.',
+        });
+    });
+});

package/clis/tvmaze/utils.js

@@ -0,0 +1,110 @@
+// Shared helpers for the TVmaze adapters.
+//
+// TVmaze publishes a free, unauthenticated REST API at https://api.tvmaze.com.
+// Docs: https://www.tvmaze.com/api
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+export const TVMAZE_BASE = 'https://api.tvmaze.com';
+const UA = 'opencli-tvmaze-adapter (+https://github.com/jackwener/opencli)';
+
+export function requireString(value, label) {
+    const s = String(value ?? '').trim();
+    if (!s) throw new ArgumentError(`tvmaze ${label} cannot be empty`);
+    return s;
+}
+
+export function requireShowId(value) {
+    const raw = value;
+    const n = typeof raw === 'number' ? raw : Number(String(raw ?? '').trim());
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(
+            'tvmaze show id is required and must be a positive integer',
+            'TVmaze show ids appear in the URL: https://www.tvmaze.com/shows/<id>/<slug>.',
+        );
+    }
+    return n;
+}
+
+export function requireBoundedInt(value, defaultValue, maxValue, label = 'limit') {
+    const raw = value ?? defaultValue;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isInteger(n) || n <= 0) {
+        throw new ArgumentError(`tvmaze ${label} must be a positive integer`);
+    }
+    if (n > maxValue) {
+        throw new ArgumentError(`tvmaze ${label} must be <= ${maxValue}`);
+    }
+    return n;
+}
+
+export async function tvmazeFetch(url, label) {
+    let resp;
+    try {
+        resp = await fetch(url, { headers: { 'user-agent': UA, accept: 'application/json' } });
+    }
+    catch (err) {
+        throw new CommandExecutionError(
+            `${label} request failed: ${err?.message ?? err}`,
+            'Check that api.tvmaze.com is reachable from this network.',
+        );
+    }
+    if (resp.status === 404) {
+        throw new EmptyResultError(label, `TVmaze returned 404 for ${url}.`);
+    }
+    if (resp.status === 429) {
+        throw new CommandExecutionError(
+            `${label} returned HTTP 429 (rate limited)`,
+            'TVmaze caps unauthenticated traffic at ~20 req/10s; wait a few seconds and retry.',
+        );
+    }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`${label} returned HTTP ${resp.status}`);
+    }
+    let body;
+    try {
+        body = await resp.json();
+    }
+    catch (err) {
+        throw new CommandExecutionError(`${label} returned malformed JSON: ${err?.message ?? err}`);
+    }
+    return body;
+}
+
+const HTML_ENTITY_MAP = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+    rsquo: '’',
+    lsquo: '‘',
+    rdquo: '”',
+    ldquo: '“',
+    hellip: '…',
+    ndash: '–',
+    mdash: '—',
+};
+
+// TVmaze ships HTML in `summary` ("<p><b>...</b> ...</p>"). Strip tags + decode
+// named and numeric entities so output is plain text.
+export function stripHtml(html) {
+    if (html == null) return '';
+    let s = String(html);
+    s = s.replace(/<[^>]+>/g, '');
+    s = s
+        .replace(/&#x([0-9a-fA-F]+);/g, (_, hex) => {
+            const code = parseInt(hex, 16);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&#(\d+);/g, (_, dec) => {
+            const code = parseInt(dec, 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : '';
+        })
+        .replace(/&([a-zA-Z]+);/g, (match, name) => HTML_ENTITY_MAP[name] ?? match);
+    return s.replace(/\s+/g, ' ').trim();
+}
+
+export function joinList(value) {
+    return Array.isArray(value) ? value.filter(Boolean).join(', ') : '';
+}

package/clis/twitter/accept.js

@@ -8,10 +8,10 @@ cli({
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
-    timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
     args: [
         { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
+        { name: 'timeout', type: 'int', required: false, default: 600, help: 'Max seconds for the overall command (default: 600 — batch op)' },
     ],
     columns: ['index', 'status', 'user', 'message'],
     func: async (page, kwargs) => {

package/clis/twitter/followers.js

@@ -1,103 +1,168 @@
-import { AuthRequiredError, selectorError } from '@jackwener/opencli/errors';
+import { ArgumentError, AuthRequiredError, selectorError, EmptyResultError } from '@jackwener/opencli/errors';
 import { cli, Strategy } from '@jackwener/opencli/registry';
+
+/**
+ * Extract follower rows from Twitter/X follower-list SPA cells.
+ *
+ * Verified DOM shape on x.com followers list (confirmed live 2026-05-05):
+ *   - `[data-testid="UserCell"]` per follower
+ *     - `[data-testid="UserAvatar-Container-<handle>"]` — stable handle source
+ *     - `[data-testid="<userId>-follow"]` — follow button (i18n-independent)
+ *     - `[data-testid="userFollowIndicator"]` — "Follows you" badge when present
+ *     - the bio (when present) is rendered into `cell.innerText` but has NO
+ *       dedicated testid in the list view (`UserDescription` only appears on
+ *       the standalone profile page, NOT inside follower-list cells).
+ *
+ * Strategy: subtract the i18n-variable button / badge texts from the lines of
+ * `cell.innerText`, treat the first remaining `@…` line as the handle, the
+ * first non-handle line as display name, and the rest as bio. We avoid
+ * locale-coupled string matching (`"Follow"` / `"关注"` / `"Folgen"`).
+ *
+ * Note: Twitter does NOT render follower COUNTS in the list view, so the
+ * `followers` column is omitted from the output schema. Use
+ * `opencli twitter profile <user>` to read a per-user follower count.
+ */
+async function extractFollowersFromDOM(page) {
+    const script = `() => {
+        const cells = document.querySelectorAll('[data-testid="UserCell"]');
+        const out = [];
+        for (const cell of cells) {
+            // Collect i18n-variable UI strings to strip from the cell text.
+            const stripTexts = new Set();
+            const buttons = cell.querySelectorAll(
+                '[data-testid$="-follow"],[data-testid$="-unfollow"],[data-testid="userFollowIndicator"]'
+            );
+            for (const el of buttons) {
+                const t = (el.innerText || '').trim();
+                if (t) stripTexts.add(t);
+            }
+            const lines = (cell.innerText || '')
+                .split('\\n')
+                .map(s => s.trim())
+                .filter(Boolean)
+                .filter(l => !stripTexts.has(l));
+            // Pull the @handle line; fall back to UserAvatar-Container-<handle>.
+            let screen_name = '';
+            const remaining = [];
+            for (const l of lines) {
+                if (!screen_name && l.startsWith('@')) {
+                    screen_name = l.slice(1).split(/\\s/)[0];
+                } else {
+                    remaining.push(l);
+                }
+            }
+            if (!screen_name) {
+                const av = cell.querySelector('[data-testid^="UserAvatar-Container-"]');
+                const tid = av ? av.getAttribute('data-testid') || '' : '';
+                if (tid.startsWith('UserAvatar-Container-')) {
+                    screen_name = tid.slice('UserAvatar-Container-'.length);
+                }
+            }
+            // First non-handle line is display name (may equal handle when the user hasn't set one).
+            const name = remaining[0] || screen_name;
+            // Lines past the display name form the bio.
+            const bio = remaining.slice(1).join(' ').replace(/\\s+/g, ' ').trim();
+            if (screen_name) {
+                out.push({ screen_name, name, bio });
+            }
+        }
+        return out;
+    }`;
+    return page.evaluate(script);
+}
+
+function normalizeScreenName(value) {
+    return String(value ?? '').trim().replace(/^\/+/, '').replace(/^@+/, '');
+}
+
 cli({
     site: 'twitter',
     name: 'followers',
     access: 'read',
     description: 'Get accounts following a Twitter/X user',
     domain: 'x.com',
-    strategy: Strategy.INTERCEPT,
+    strategy: Strategy.UI,
     browser: true,
     args: [
         { name: 'user', positional: true, type: 'string', required: false },
         { name: 'limit', type: 'int', default: 50 },
     ],
-    columns: ['screen_name', 'name', 'bio', 'followers'],
+    // `followers` (count) is NOT exposed: the SPA followers-list view does not
+    // render it. Use `twitter profile <user>` for per-user follower counts.
+    columns: ['screen_name', 'name', 'bio'],
     func: async (page, kwargs) => {
-        let targetUser = kwargs.user;
-        // If no user is specified, figure out the logged-in user's handle
+        const limit = kwargs.limit;
+        if (!Number.isInteger(limit) || limit <= 0) {
+            throw new ArgumentError('limit must be a positive integer');
+        }
+
+        let targetUser = normalizeScreenName(kwargs.user);
         if (!targetUser) {
             await page.goto('https://x.com/home');
             await page.wait({ selector: '[data-testid="primaryColumn"]' });
             const href = await page.evaluate(`() => {
-            const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
-            return link ? link.getAttribute('href') : null;
-        }`);
+                const link = document.querySelector('a[data-testid="AppTabBar_Profile_Link"]');
+                return link ? link.getAttribute('href') : null;
+            }`);
             if (!href) {
                 throw new AuthRequiredError('x.com', 'Could not find logged-in user profile link. Are you logged in?');
             }
-            targetUser = href.replace('/', '');
+            targetUser = normalizeScreenName(href);
         }
+        if (!targetUser) {
+            throw new ArgumentError('twitter followers user cannot be empty', 'Example: opencli twitter followers @elonmusk --limit 100');
+        }
+
         // 1. Navigate to profile page
         await page.goto(`https://x.com/${targetUser}`);
         await page.wait(3);
-        // 2. Install interceptor BEFORE SPA navigation.
-        //    goto() resets JS context, but SPA click preserves it.
-        await page.installInterceptor('Followers');
-        // 3. Click the followers link via SPA navigation (preserves interceptor).
-        //    Twitter uses /verified_followers instead of /followers now.
+
+        // 2. Click the followers tab via SPA navigation (preserves session/state).
+        //    Twitter sometimes only renders /verified_followers on profiles with
+        //    badge filtering enabled; try the canonical link first, fall back.
         const safeUser = JSON.stringify(targetUser);
         const clicked = await page.evaluate(`() => {
-        const target = ${safeUser};
-        const selectors = [
-            'a[href="/' + target + '/verified_followers"]',
-            'a[href="/' + target + '/followers"]',
-        ];
-        for (const sel of selectors) {
-            const link = document.querySelector(sel);
-            if (link) { link.click(); return true; }
-        }
-        return false;
-    }`);
+            const target = ${safeUser};
+            const selectors = [
+                'a[href="/' + target + '/followers"]',
+                'a[href="/' + target + '/verified_followers"]',
+            ];
+            for (const sel of selectors) {
+                const link = document.querySelector(sel);
+                if (link) { link.click(); return true; }
+            }
+            return false;
+        }`);
         if (!clicked) {
             throw selectorError('Twitter followers link', 'Twitter may have changed the layout.');
         }
-        await page.waitForCapture(5);
-        // 4. Scroll to trigger pagination API calls
-        await page.autoScroll({ times: Math.ceil(kwargs.limit / 20), delayMs: 2000 });
-        // 5. Retrieve intercepted data
-        const requests = await page.getInterceptedRequests();
-        const requestList = Array.isArray(requests) ? requests : [];
-        if (requestList.length === 0) {
-            return [];
-        }
-        let results = [];
-        for (const req of requestList) {
-            try {
-                // GraphQL response: { data: { user: { result: { timeline: ... } } } }
-                let instructions = req.data?.user?.result?.timeline?.timeline?.instructions;
-                if (!instructions)
-                    continue;
-                let addEntries = instructions.find((i) => i.type === 'TimelineAddEntries');
-                if (!addEntries) {
-                    addEntries = instructions.find((i) => i.entries && Array.isArray(i.entries));
-                }
-                if (!addEntries)
-                    continue;
-                for (const entry of addEntries.entries) {
-                    if (!entry.entryId.startsWith('user-'))
-                        continue;
-                    const item = entry.content?.itemContent?.user_results?.result;
-                    if (!item || item.__typename !== 'User')
-                        continue;
-                    const core = item.core || {};
-                    const legacy = item.legacy || {};
-                    results.push({
-                        screen_name: core.screen_name || legacy.screen_name || 'unknown',
-                        name: core.name || legacy.name || 'unknown',
-                        bio: legacy.description || item.profile_bio?.description || '',
-                        followers: legacy.followers_count || legacy.normal_followers_count || 0
-                    });
-                }
+
+        // 3. Wait for follower cells to appear
+        await page.wait({ selector: '[data-testid="UserCell"]', timeout: 10000 });
+
+        // 4. Extract from DOM, scroll to load more, dedupe by screen_name
+        const allFollowers = [];
+        const seen = new Set();
+        let sameCount = 0;
+        while (allFollowers.length < limit && sameCount < 3) {
+            const followers = await extractFollowersFromDOM(page);
+            const newFollowers = followers.filter(f => !seen.has(f.screen_name));
+            for (const f of newFollowers) {
+                seen.add(f.screen_name);
+                allFollowers.push(f);
             }
-            catch (e) {
-                // ignore parsing errors for individual payloads
+            if (newFollowers.length === 0) {
+                sameCount++;
+            } else {
+                sameCount = 0;
             }
+            if (allFollowers.length >= limit) break;
+            await page.autoScroll({ times: 1, delayMs: 500 });
+            await page.wait(2);
+        }
+        if (allFollowers.length === 0) {
+            throw new EmptyResultError('twitter followers', `No followers found for @${targetUser}`);
         }
-        // Deduplicate by screen_name
-        const unique = new Map();
-        results.forEach(r => unique.set(r.screen_name, r));
-        const deduplicatedResults = Array.from(unique.values());
-        return deduplicatedResults.slice(0, kwargs.limit);
+        return allFollowers.slice(0, limit);
     }
 });

package/clis/twitter/quote.js

@@ -0,0 +1,139 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl } from './shared.js';
+
+function extractTweetId(url) {
+    return parseTweetUrl(url).id;
+}
+
+function buildQuoteComposerUrl(url) {
+    // Twitter/X quote-tweet compose URL: the `url` param attaches the source
+    // tweet as a quoted card. Validating tweet-id shape early surfaces obvious
+    // typos before any browser interaction.
+    const parsed = parseTweetUrl(url);
+    return `https://x.com/compose/post?url=${encodeURIComponent(parsed.url)}`;
+}
+
+async function submitQuote(page, text, tweetId) {
+    return page.evaluate(`(async () => {
+        try {
+            const visible = (el) => !!el && (el.offsetParent !== null || el.getClientRects().length > 0);
+            const getStatusId = (href) => {
+                try {
+                    const match = new URL(href, window.location.origin).pathname.match(/^\\/(?:[^/]+|i)\\/status\\/(\\d+)\\/?$/);
+                    return match?.[1] || null;
+                } catch {
+                    return null;
+                }
+            };
+            const boxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]'));
+            const box = boxes.find(visible) || boxes[0];
+            if (!box) {
+                return { ok: false, message: 'Could not find the quote composer text area. Are you logged in?' };
+            }
+
+            box.focus();
+            const textToInsert = ${JSON.stringify(text)};
+            const tweetId = ${JSON.stringify(tweetId)};
+            // execCommand('insertText') is more reliable with Twitter's Draft.js editor.
+            if (!document.execCommand('insertText', false, textToInsert)) {
+                // Fallback to paste event if execCommand fails.
+                const dataTransfer = new DataTransfer();
+                dataTransfer.setData('text/plain', textToInsert);
+                box.dispatchEvent(new ClipboardEvent('paste', {
+                    clipboardData: dataTransfer,
+                    bubbles: true,
+                    cancelable: true,
+                }));
+            }
+
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Confirm the quoted card is rendered before submitting; otherwise we may
+            // accidentally post a plain tweet without the quote attachment.
+            let cardAttempts = 0;
+            let hasQuoteCard = false;
+            while (cardAttempts < 20) {
+                hasQuoteCard = Array.from(document.querySelectorAll('a[href*="/status/"]'))
+                    .some((link) => getStatusId(link.href) === tweetId);
+                if (hasQuoteCard) break;
+                await new Promise(r => setTimeout(r, 250));
+                cardAttempts++;
+            }
+            if (!hasQuoteCard) {
+                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');
+            if (!btn) {
+                return { ok: false, message: 'Tweet button is disabled or not found.' };
+            }
+
+            btn.click();
+
+            const normalize = s => String(s || '').replace(/\\u00a0/g, ' ').replace(/\\s+/g, ' ').trim();
+            const expectedText = normalize(textToInsert);
+            for (let i = 0; i < 30; i++) {
+                await new Promise(r => setTimeout(r, 500));
+                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: 'Quote tweet posted successfully.' };
+                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 || 'Quote tweet failed to post.').trim() };
+
+                const visibleBoxes = Array.from(document.querySelectorAll('[data-testid="tweetTextarea_0"]')).filter(visible);
+                const composerStillHasText = visibleBoxes.some((box) =>
+                    normalize(box.innerText || box.textContent || '').includes(expectedText)
+                );
+                if (!composerStillHasText) return { ok: true, message: 'Quote tweet posted successfully.' };
+            }
+            return { ok: false, message: 'Quote tweet submission did not complete before timeout.' };
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+}
+
+cli({
+    site: 'twitter',
+    name: 'quote',
+    access: 'write',
+    description: 'Quote-tweet a specific tweet with your own text',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    args: [
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to quote' },
+        { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of your quote' },
+    ],
+    columns: ['status', 'message', 'text'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter quote');
+
+        // Dedicated composer is more reliable than the inline quote-tweet button.
+        const target = parseTweetUrl(kwargs.url);
+        await page.goto(`https://x.com/compose/post?url=${encodeURIComponent(target.url)}`, { waitUntil: 'load', settleMs: 2500 });
+        await page.wait({ selector: '[data-testid="tweetTextarea_0"]', timeout: 15 });
+
+        const result = await submitQuote(page, kwargs.text, target.id);
+        if (result.ok) {
+            // Wait for network submission to complete
+            await page.wait(3);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message,
+                text: kwargs.text,
+            }];
+    }
+});
+
+export const __test__ = {
+    buildQuoteComposerUrl,
+    extractTweetId,
+};