@jackwener/opencli 1.7.12 → 1.7.14

package/clis/twitter/quote.test.js

@@ -0,0 +1,106 @@
+import { describe, expect, it } 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('extracts tweet ids from both user and i/status URLs', () => {
+        expect(__test__.extractTweetId('https://x.com/alice/status/2040254679301718161?s=20')).toBe('2040254679301718161');
+        expect(__test__.extractTweetId('https://x.com/i/status/2040318731105313143')).toBe('2040318731105313143');
+    });
+
+    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.
+        expect(script).toContain('Quote target did not render');
+        expect(script).toContain('document.execCommand');
+        expect(script).toContain('tweetButton');
+        expect(script).toContain('getStatusId(link.href) === tweetId');
+        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('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-dm.js

@@ -8,11 +8,11 @@ cli({
     domain: 'x.com',
     strategy: Strategy.UI,
     browser: true,
-    timeoutSeconds: 600, // 10 min — batch operation
     args: [
         { name: 'text', type: 'string', required: true, positional: true, help: 'Message text to send (e.g. "我的微信 wxkabi")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of conversations to reply to (default: 20)' },
         { name: 'skip-replied', type: 'boolean', required: false, default: true, help: 'Skip conversations where you already sent the same text (default: true)' },
+        { 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/reply.test.js

@@ -4,35 +4,7 @@ import * as path from 'node:path';
 import { describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
 import { __test__ } from './reply.js';
-function createPageMock(evaluateResults, overrides = {}) {
-    const evaluate = vi.fn();
-    for (const result of evaluateResults) {
-        evaluate.mockResolvedValueOnce(result);
-    }
-    return {
-        goto: vi.fn().mockResolvedValue(undefined),
-        evaluate,
-        snapshot: vi.fn().mockResolvedValue(undefined),
-        click: vi.fn().mockResolvedValue(undefined),
-        typeText: vi.fn().mockResolvedValue(undefined),
-        pressKey: vi.fn().mockResolvedValue(undefined),
-        scrollTo: vi.fn().mockResolvedValue(undefined),
-        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
-        wait: vi.fn().mockResolvedValue(undefined),
-        tabs: vi.fn().mockResolvedValue([]),
-        selectTab: vi.fn().mockResolvedValue(undefined),
-        networkRequests: vi.fn().mockResolvedValue([]),
-        consoleMessages: vi.fn().mockResolvedValue([]),
-        scroll: vi.fn().mockResolvedValue(undefined),
-        autoScroll: vi.fn().mockResolvedValue(undefined),
-        installInterceptor: vi.fn().mockResolvedValue(undefined),
-        getInterceptedRequests: vi.fn().mockResolvedValue([]),
-        getCookies: vi.fn().mockResolvedValue([]),
-        screenshot: vi.fn().mockResolvedValue(''),
-        waitForCapture: vi.fn().mockResolvedValue(undefined),
-        ...overrides,
-    };
-}
+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');

package/clis/twitter/retweet.js

@@ -0,0 +1,99 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl } 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 {
+            const tweetId = ${JSON.stringify(target.id)};
+            const findTargetArticle = () => Array.from(document.querySelectorAll('article')).find((article) =>
+                Array.from(article.querySelectorAll('a[href*="/status/"]')).some((link) => {
+                    try {
+                        const match = new URL(link.href, window.location.origin).pathname.match(/^\/(?:[^/]+|i)\/status\/(\d+)\/?$/);
+                        return match?.[1] === tweetId;
+                    } catch {
+                        return false;
+                    }
+                })
+            );
+            // Poll for the tweet to render
+            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 the confirm menu item to appear, then click it
+            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
+            }];
+    }
+});

package/clis/twitter/retweet.test.js

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './retweet.js';
+import { createPageMock } from '../test-utils.js';
+
+describe('twitter retweet command', () => {
+    it('clicks the retweet button then the confirm menu item and reports success', async () => {
+        const cmd = getRegistry().get('twitter/retweet');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: true, message: 'Tweet successfully retweeted.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/alice/status/2040254679301718161');
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="primaryColumn"]' });
+        expect(page.wait).toHaveBeenNthCalledWith(2, 2);
+        const script = page.evaluate.mock.calls[0][0];
+        // Two-step UI flow must be present:
+        //   1) click the retweet button
+        //   2) wait for and click the confirm menu item (data-testid="retweetConfirm")
+        expect(script).toContain('retweetBtn.click()');
+        expect(script).toContain("document.querySelector('[data-testid=\"retweetConfirm\"]')");
+        expect(script).toContain('confirmBtn.click()');
+        expect(script).toContain("document.querySelectorAll('article')");
+        expect(script).toContain('match?.[1] === tweetId');
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"retweet\"]')");
+        // Idempotency probe: when already retweeted ([data-testid="unretweet"] present),
+        // the script returns ok:true with an "already retweeted" message.
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"unretweet\"]')");
+        expect(result).toEqual([
+            { status: 'success', message: 'Tweet successfully retweeted.' },
+        ]);
+    });
+
+    it('returns a failed row when the confirm menu item never appears', async () => {
+        const cmd = getRegistry().get('twitter/retweet');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: false, message: 'Retweet menu opened but the confirm option did not appear.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(result).toEqual([
+            { status: 'failed', message: 'Retweet menu opened but the confirm option did not appear.' },
+        ]);
+        expect(page.wait).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws CommandExecutionError when no page is provided', async () => {
+        const cmd = getRegistry().get('twitter/retweet');
+        await expect(cmd.func(undefined, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('rejects invalid tweet URLs before navigation', async () => {
+        const cmd = getRegistry().get('twitter/retweet');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'https://evil.com/?next=https://x.com/alice/status/2040254679301718161',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+});

package/clis/twitter/shared.js

@@ -1,4 +1,41 @@
+import { ArgumentError } from '@jackwener/opencli/errors';
+
 const QUERY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+const TWEET_PATH_PATTERN = /^\/(?:[^/]+|i)\/status\/(\d+)\/?$/;
+const TWEET_HOSTS = new Set(['x.com', 'twitter.com']);
+
+function isTwitterHost(hostname) {
+    return TWEET_HOSTS.has(hostname)
+        || hostname.endsWith('.x.com')
+        || hostname.endsWith('.twitter.com');
+}
+
+export function parseTweetUrl(rawUrl) {
+    const value = String(rawUrl ?? '').trim();
+    if (!value) {
+        throw new ArgumentError('twitter tweet URL cannot be empty', 'Example: opencli twitter retweet https://x.com/jack/status/20');
+    }
+    let parsed;
+    try {
+        parsed = new URL(value);
+    }
+    catch {
+        throw new ArgumentError(`Invalid tweet URL: ${value}`, 'Use a full https://x.com/<user>/status/<id> URL');
+    }
+    const hostname = parsed.hostname.toLowerCase();
+    if (parsed.protocol !== 'https:' || !isTwitterHost(hostname)) {
+        throw new ArgumentError(`Invalid tweet URL host: ${value}`, 'Use a full https://x.com/<user>/status/<id> URL');
+    }
+    const match = parsed.pathname.match(TWEET_PATH_PATTERN);
+    if (!match?.[1]) {
+        throw new ArgumentError(`Could not extract tweet ID from URL: ${value}`, 'Use a full https://x.com/<user>/status/<id> URL');
+    }
+    return {
+        id: match[1],
+        url: parsed.toString(),
+    };
+}
+
 export function sanitizeQueryId(resolved, fallbackId) {
     return typeof resolved === 'string' && QUERY_ID_PATTERN.test(resolved) ? resolved : fallbackId;
 }
@@ -65,4 +102,5 @@ export function extractMedia(legacy) {
 export const __test__ = {
     sanitizeQueryId,
     extractMedia,
+    parseTweetUrl,
 };

package/clis/twitter/shared.test.js

@@ -1,7 +1,34 @@
 import { describe, expect, it } from 'vitest';
 import { __test__ } from './shared.js';
+import { ArgumentError } from '@jackwener/opencli/errors';
 
-const { extractMedia } = __test__;
+const { extractMedia, parseTweetUrl } = __test__;
+
+describe('twitter parseTweetUrl', () => {
+    it('accepts exact Twitter/X tweet URLs and preserves query parameters', () => {
+        expect(parseTweetUrl('https://x.com/alice/status/2040254679301718161?s=20')).toEqual({
+            id: '2040254679301718161',
+            url: 'https://x.com/alice/status/2040254679301718161?s=20',
+        });
+        expect(parseTweetUrl('https://mobile.twitter.com/i/status/2040318731105313143')).toEqual({
+            id: '2040318731105313143',
+            url: 'https://mobile.twitter.com/i/status/2040318731105313143',
+        });
+    });
+
+    it('rejects non-https, off-domain, host-suffix, embedded, and path-suffix URLs', () => {
+        const invalid = [
+            'http://x.com/alice/status/2040254679301718161',
+            'https://evil.com/alice/status/2040254679301718161',
+            'https://x.com.evil.com/alice/status/2040254679301718161',
+            'https://evil.com/?next=https://x.com/alice/status/2040254679301718161',
+            'https://x.com/alice/status/2040254679301718161/photo/1',
+        ];
+        for (const url of invalid) {
+            expect(() => parseTweetUrl(url)).toThrow(ArgumentError);
+        }
+    });
+});
 
 describe('twitter extractMedia', () => {
     it('returns false + empty list when legacy has no media', () => {

package/clis/twitter/unlike.js

@@ -0,0 +1,87 @@
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { parseTweetUrl } from './shared.js';
+
+cli({
+    site: 'twitter',
+    name: 'unlike',
+    access: 'write',
+    description: 'Remove a like from 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 unlike' },
+    ],
+    columns: ['status', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new CommandExecutionError('Browser session required for twitter unlike');
+        const target = parseTweetUrl(kwargs.url);
+        await page.goto(target.url);
+        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        const result = await page.evaluate(`(async () => {
+        try {
+            const tweetId = ${JSON.stringify(target.id)};
+            const findTargetArticle = () => Array.from(document.querySelectorAll('article')).find((article) =>
+                Array.from(article.querySelectorAll('a[href*="/status/"]')).some((link) => {
+                    try {
+                        const match = new URL(link.href, window.location.origin).pathname.match(/^\/(?:[^/]+|i)\/status\/(\d+)\/?$/);
+                        return match?.[1] === tweetId;
+                    } catch {
+                        return false;
+                    }
+                })
+            );
+            // Poll for the tweet to render
+            let attempts = 0;
+            let likeBtn = null;
+            let unlikeBtn = null;
+            let targetArticle = null;
+
+            while (attempts < 20) {
+                targetArticle = findTargetArticle();
+                likeBtn = targetArticle?.querySelector('[data-testid="like"]') || null;
+                unlikeBtn = targetArticle?.querySelector('[data-testid="unlike"]') || null;
+
+                if (likeBtn || unlikeBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            // Check if it's already not liked
+            if (likeBtn) {
+                return { ok: true, message: 'Tweet is not liked (already unliked).' };
+            }
+
+            if (!unlikeBtn) {
+                return { ok: false, message: 'Could not find the Unlike button on this tweet after waiting 10 seconds. Are you logged in?' };
+            }
+
+            // Click Unlike
+            unlikeBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Verify success by checking if the 'like' button reappeared
+            const verifyArticle = findTargetArticle() || targetArticle;
+            const verifyBtn = verifyArticle?.querySelector('[data-testid="like"]');
+            if (verifyBtn) {
+                return { ok: true, message: 'Tweet successfully unliked.' };
+            } else {
+                return { ok: false, message: 'Unlike action was initiated but UI did not update as expected.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+        if (result.ok) {
+            // Wait for the unlike network request to be processed
+            await page.wait(2);
+        }
+        return [{
+                status: result.ok ? 'success' : 'failed',
+                message: result.message
+            }];
+    }
+});

package/clis/twitter/unlike.test.js

@@ -0,0 +1,72 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './unlike.js';
+import { createPageMock } from '../test-utils.js';
+
+describe('twitter unlike command', () => {
+    it('navigates to the tweet URL and reports success when the unlike script confirms', async () => {
+        const cmd = getRegistry().get('twitter/unlike');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: true, message: 'Tweet successfully unliked.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/alice/status/2040254679301718161');
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="primaryColumn"]' });
+        // After ok:true the adapter waits an extra 2s for the network round-trip.
+        expect(page.wait).toHaveBeenNthCalledWith(2, 2);
+        const script = page.evaluate.mock.calls[0][0];
+        // Idempotency check: looks for the like button (already-not-liked path) before clicking unlike.
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"like\"]')");
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"unlike\"]')");
+        expect(script).toContain('unlikeBtn.click()');
+        expect(script).toContain("document.querySelectorAll('article')");
+        expect(script).toContain('match?.[1] === tweetId');
+        expect(script).toContain("targetArticle?.querySelector('[data-testid=\"unlike\"]')");
+        expect(result).toEqual([
+            { status: 'success', message: 'Tweet successfully unliked.' },
+        ]);
+    });
+
+    it('returns a failed row without re-waiting when the unlike script reports a UI mismatch', async () => {
+        const cmd = getRegistry().get('twitter/unlike');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            {
+                ok: false,
+                message: 'Could not find the Unlike button on this tweet after waiting 10 seconds. Are you logged in?',
+            },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        });
+        expect(result).toEqual([
+            {
+                status: 'failed',
+                message: 'Could not find the Unlike button on this tweet after waiting 10 seconds. Are you logged in?',
+            },
+        ]);
+        // Only the primaryColumn wait should run when ok is false.
+        expect(page.wait).toHaveBeenCalledTimes(1);
+    });
+
+    it('throws CommandExecutionError when no page is provided', async () => {
+        const cmd = getRegistry().get('twitter/unlike');
+        await expect(cmd.func(undefined, {
+            url: 'https://x.com/alice/status/2040254679301718161',
+        })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('rejects invalid tweet URLs before navigation', async () => {
+        const cmd = getRegistry().get('twitter/unlike');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'https://x.com/alice/status/2040254679301718161/photo/1',
+        })).rejects.toThrow(ArgumentError);
+        expect(page.goto).not.toHaveBeenCalled();
+        expect(page.evaluate).not.toHaveBeenCalled();
+    });
+});