@jackwener/opencli 1.6.0 → 1.6.2

package/dist/clis/twitter/reply.test.js

@@ -0,0 +1,151 @@
+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 { getRegistry } from '../../registry.js';
+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,
+    };
+}
+describe('twitter reply command', () => {
+    it('keeps the text-only reply flow working', async () => {
+        const cmd = getRegistry().get('twitter/reply');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            { ok: true, message: 'Reply posted successfully.' },
+        ]);
+        const result = await cmd.func(page, {
+            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
+            text: 'text-only reply',
+        });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/_kop6/status/2040254679301718161?s=20');
+        expect(page.wait).toHaveBeenCalledWith({ selector: '[data-testid="primaryColumn"]' });
+        expect(result).toEqual([
+            {
+                status: 'success',
+                message: 'Reply posted successfully.',
+                text: 'text-only reply',
+            },
+        ]);
+    });
+    it('uploads a local image through the dedicated reply composer when --image is provided', async () => {
+        const cmd = getRegistry().get('twitter/reply');
+        expect(cmd?.func).toBeTypeOf('function');
+        const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-twitter-reply-'));
+        const imagePath = path.join(tempDir, 'qr.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: 'Reply posted successfully.' },
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
+            text: 'reply with image',
+            image: imagePath,
+        });
+        expect(page.goto).toHaveBeenCalledWith('https://x.com/compose/post?in_reply_to=2040254679301718161');
+        expect(page.wait).toHaveBeenNthCalledWith(1, { selector: '[data-testid="tweetTextarea_0"]' });
+        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: 'Reply posted successfully.',
+                text: 'reply with image',
+                image: imagePath,
+            },
+        ]);
+    });
+    it('downloads a remote image before uploading when --image-url is provided', async () => {
+        const cmd = getRegistry().get('twitter/reply');
+        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: 'Reply posted successfully.' },
+        ], {
+            setFileInput,
+        });
+        const result = await cmd.func(page, {
+            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
+            text: 'reply with remote image',
+            'image-url': 'https://example.com/qr',
+        });
+        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$/);
+        expect(fs.existsSync(uploadedPath)).toBe(false);
+        expect(result).toEqual([
+            {
+                status: 'success',
+                message: 'Reply posted successfully.',
+                text: 'reply with remote image',
+                'image-url': 'https://example.com/qr',
+            },
+        ]);
+        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');
+        const page = createPageMock([]);
+        await expect(cmd.func(page, {
+            url: 'https://x.com/_kop6/status/2040254679301718161?s=20',
+            text: 'nope',
+            image: '/tmp/a.png',
+            'image-url': 'https://example.com/a.png',
+        })).rejects.toThrow('Use either --image or --image-url, not both.');
+    });
+    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');
+        expect(__test__.buildReplyComposerUrl('https://x.com/i/status/2040318731105313143'))
+            .toBe('https://x.com/compose/post?in_reply_to=2040318731105313143');
+    });
+    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');
+    });
+});

package/dist/clis/twitter/search.js

@@ -1,15 +1,18 @@
 import { CommandExecutionError } from '../../errors.js';
 import { cli, Strategy } from '../../registry.js';
 /**
- * Trigger Twitter search SPA navigation and retry once on transient failures.
+ * Trigger Twitter search SPA navigation with fallback strategies.
  *
- * Twitter/X sometimes keeps the page on /explore for a short period even after
- * pushState + popstate. A second attempt is enough for the intermittent cases
- * reported in issue #353 while keeping the flow narrowly scoped.
+ * Primary: pushState + popstate (works in most environments).
+ * Fallback: Type into the search input and press Enter when pushState fails
+ *   intermittently (e.g. due to Twitter A/B tests or timing races — see #690).
+ *
+ * Both strategies preserve the JS context so the fetch interceptor stays alive.
  */
 async function navigateToSearch(page, query, filter) {
     const searchUrl = JSON.stringify(`/search?q=${encodeURIComponent(query)}&f=${filter}`);
     let lastPath = '';
+    // Strategy 1 (primary): pushState + popstate with retry
     for (let attempt = 1; attempt <= 2; attempt++) {
         await page.evaluate(`
       (() => {
@@ -17,7 +20,12 @@ async function navigateToSearch(page, query, filter) {
         window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
       })()
     `);
-        await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        try {
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        }
+        catch {
+            // selector timeout — fall through to path check or next attempt
+        }
         lastPath = String(await page.evaluate('() => window.location.pathname') || '');
         if (lastPath.startsWith('/search')) {
             return;
@@ -26,6 +34,60 @@ async function navigateToSearch(page, query, filter) {
             await page.wait(1);
         }
     }
+    // Strategy 2 (fallback): Use the search input on /explore.
+    // The nativeSetter + Enter approach triggers Twitter's own form handler,
+    // performing SPA navigation without a full page reload.
+    const queryStr = JSON.stringify(query);
+    const navResult = await page.evaluate(`(async () => {
+    try {
+      const input = document.querySelector('[data-testid="SearchBox_Search_Input"]');
+      if (!input) return { ok: false };
+
+      input.focus();
+      await new Promise(r => setTimeout(r, 300));
+
+      const nativeSetter = Object.getOwnPropertyDescriptor(
+        window.HTMLInputElement.prototype, 'value'
+      )?.set;
+      if (!nativeSetter) return { ok: false };
+      nativeSetter.call(input, ${queryStr});
+      input.dispatchEvent(new Event('input', { bubbles: true }));
+      input.dispatchEvent(new Event('change', { bubbles: true }));
+      await new Promise(r => setTimeout(r, 500));
+
+      input.dispatchEvent(new KeyboardEvent('keydown', {
+        key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true
+      }));
+
+      return { ok: true };
+    } catch {
+      return { ok: false };
+    }
+  })()`);
+    if (navResult?.ok) {
+        try {
+            await page.wait({ selector: '[data-testid="primaryColumn"]' });
+        }
+        catch {
+            // fall through to path check
+        }
+        lastPath = String(await page.evaluate('() => window.location.pathname') || '');
+        if (lastPath.startsWith('/search')) {
+            if (filter === 'live') {
+                await page.evaluate(`(() => {
+          const tabs = document.querySelectorAll('[role="tab"]');
+          for (const tab of tabs) {
+            if (tab.textContent.includes('Latest') || tab.textContent.includes('最新')) {
+              tab.click();
+              return;
+            }
+          }
+        })()`);
+                await page.wait(2);
+            }
+            return;
+        }
+    }
     throw new CommandExecutionError(`SPA navigation to /search failed. Final path: ${lastPath || '(empty)'}. Twitter may have changed its routing.`);
 }
 cli({

package/dist/clis/twitter/search.test.js

@@ -132,14 +132,92 @@ describe('twitter search command', () => {
         const pushStateCall = evaluate.mock.calls[0][0];
         expect(pushStateCall).toContain('f=top');
     });
+    it('falls back to search input when pushState fails twice', async () => {
+        const command = getRegistry().get('twitter/search');
+        expect(command?.func).toBeTypeOf('function');
+        const evaluate = vi.fn()
+            .mockResolvedValueOnce(undefined) // pushState attempt 1
+            .mockResolvedValueOnce('/explore') // pathname check 1 — not /search
+            .mockResolvedValueOnce(undefined) // pushState attempt 2
+            .mockResolvedValueOnce('/explore') // pathname check 2 — still not /search
+            .mockResolvedValueOnce({ ok: true }) // search input fallback succeeds
+            .mockResolvedValueOnce('/search'); // pathname check after fallback
+        const page = {
+            goto: vi.fn().mockResolvedValue(undefined),
+            wait: vi.fn().mockResolvedValue(undefined),
+            installInterceptor: vi.fn().mockResolvedValue(undefined),
+            evaluate,
+            autoScroll: vi.fn().mockResolvedValue(undefined),
+            getInterceptedRequests: vi.fn().mockResolvedValue([
+                {
+                    data: {
+                        search_by_raw_query: {
+                            search_timeline: {
+                                timeline: {
+                                    instructions: [
+                                        {
+                                            type: 'TimelineAddEntries',
+                                            entries: [
+                                                {
+                                                    entryId: 'tweet-99',
+                                                    content: {
+                                                        itemContent: {
+                                                            tweet_results: {
+                                                                result: {
+                                                                    rest_id: '99',
+                                                                    legacy: {
+                                                                        full_text: 'fallback works',
+                                                                        favorite_count: 3,
+                                                                        created_at: 'Wed Apr 02 12:00:00 +0000 2026',
+                                                                    },
+                                                                    core: {
+                                                                        user_results: {
+                                                                            result: {
+                                                                                core: { screen_name: 'bob' },
+                                                                            },
+                                                                        },
+                                                                    },
+                                                                    views: { count: '5' },
+                                                                },
+                                                            },
+                                                        },
+                                                    },
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            },
+                        },
+                    },
+                },
+            ]),
+        };
+        const result = await command.func(page, { query: 'test fallback', filter: 'top', limit: 5 });
+        expect(result).toEqual([
+            {
+                id: '99',
+                author: 'bob',
+                text: 'fallback works',
+                created_at: 'Wed Apr 02 12:00:00 +0000 2026',
+                likes: 3,
+                views: '5',
+                url: 'https://x.com/i/status/99',
+            },
+        ]);
+        // 6 evaluate calls: 2x pushState + 2x pathname check + 1x fallback + 1x pathname check
+        expect(evaluate).toHaveBeenCalledTimes(6);
+        expect(page.autoScroll).toHaveBeenCalled();
+    });
     it('throws with the final path after both attempts fail', async () => {
         const command = getRegistry().get('twitter/search');
         expect(command?.func).toBeTypeOf('function');
         const evaluate = vi.fn()
-            .mockResolvedValueOnce(undefined)
-            .mockResolvedValueOnce('/explore')
-            .mockResolvedValueOnce(undefined)
-            .mockResolvedValueOnce('/login');
+            .mockResolvedValueOnce(undefined) // pushState attempt 1
+            .mockResolvedValueOnce('/explore') // pathname check 1
+            .mockResolvedValueOnce(undefined) // pushState attempt 2
+            .mockResolvedValueOnce('/login') // pathname check 2
+            .mockResolvedValueOnce({ ok: false }); // search input fallback
         const page = {
             goto: vi.fn().mockResolvedValue(undefined),
             wait: vi.fn().mockResolvedValue(undefined),
@@ -153,6 +231,6 @@ describe('twitter search command', () => {
             .toThrow('Final path: /login');
         expect(page.autoScroll).not.toHaveBeenCalled();
         expect(page.getInterceptedRequests).not.toHaveBeenCalled();
-        expect(evaluate).toHaveBeenCalledTimes(4);
+        expect(evaluate).toHaveBeenCalledTimes(5);
     });
 });

package/dist/clis/xianyu/chat.d.ts

@@ -0,0 +1,7 @@
+import { normalizeNumericId } from './utils.js';
+declare function buildChatUrl(itemId: string, peerUserId: string): string;
+export declare const __test__: {
+    normalizeNumericId: typeof normalizeNumericId;
+    buildChatUrl: typeof buildChatUrl;
+};
+export {};

package/dist/clis/xianyu/chat.js

@@ -0,0 +1,146 @@
+import { AuthRequiredError, SelectorError } from '../../errors.js';
+import { cli, Strategy } from '../../registry.js';
+import { normalizeNumericId } from './utils.js';
+function buildChatUrl(itemId, peerUserId) {
+    return `https://www.goofish.com/im?itemId=${encodeURIComponent(itemId)}&peerUserId=${encodeURIComponent(peerUserId)}`;
+}
+function buildExtractChatStateEvaluate() {
+    return `
+    (() => {
+      const clean = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const bodyText = document.body?.innerText || '';
+      const requiresAuth = /请先登录|登录后/.test(bodyText);
+
+      const textarea = document.querySelector('textarea');
+      const sendButton = Array.from(document.querySelectorAll('button'))
+        .find((btn) => clean(btn.textContent || '') === '发送');
+      const topbar = document.querySelector('[class*="message-topbar"]');
+      const itemCard = Array.from(document.querySelectorAll('a[href*="/item?id="]'))
+        .find((el) => el.closest('main'));
+      const itemTitleNode =
+        document.querySelector('[class*="container"] [class*="title"]')
+        || document.querySelector('[class*="item-main-info"] [class*="desc"]')
+        || document.querySelector('[class*="headSkuInfo"]')
+        || itemCard?.querySelector('[class*="title"]')
+        || itemCard?.previousElementSibling?.querySelector?.('[class*="title"]');
+
+      const messageRoot = document.querySelector('#message-list-scrollable');
+      const visibleMessages = Array.from(
+        (messageRoot || document).querySelectorAll('[class*="message"], [class*="msg"], [class*="bubble"]')
+      ).map((el) => clean(el.textContent || ''))
+        .filter(Boolean)
+        .filter((text) => !['发送', '闲鱼号', '立即购买'].includes(text))
+        .filter((text) => !/^消息\\d*\\+?$/.test(text))
+        .slice(-20);
+
+      return {
+        requiresAuth,
+        title: clean(document.title || ''),
+        peer_name: clean(topbar?.querySelector('[class*="text1"]')?.textContent || ''),
+        peer_masked_id: clean(topbar?.querySelector('[class*="text2"]')?.textContent || '').replace(/^\\(|\\)$/g, ''),
+        item_title: clean(itemTitleNode?.textContent || ''),
+        item_url: itemCard?.href || '',
+        price: clean(itemCard?.querySelector('[class*="money"]')?.textContent || ''),
+        location: clean(itemCard?.querySelector('[class*="delivery"] + [class*="delivery"], [class*="delivery"]:last-child')?.textContent || ''),
+        can_input: Boolean(textarea && !textarea.disabled),
+        can_send: Boolean(sendButton),
+        visible_messages: visibleMessages,
+      };
+    })()
+  `;
+}
+function buildSendMessageEvaluate(text) {
+    return `
+    (() => {
+      const clean = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const textarea = document.querySelector('textarea');
+      if (!textarea || textarea.disabled) {
+        return { ok: false, reason: 'input-not-found' };
+      }
+
+      const setter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
+      if (!setter) {
+        return { ok: false, reason: 'textarea-setter-not-found' };
+      }
+
+      textarea.focus();
+      setter.call(textarea, ${JSON.stringify(text)});
+      textarea.dispatchEvent(new Event('input', { bubbles: true }));
+      textarea.dispatchEvent(new Event('change', { bubbles: true }));
+
+      const sendButton = Array.from(document.querySelectorAll('button'))
+        .find((btn) => clean(btn.textContent || '') === '发送');
+      if (!sendButton) {
+        return { ok: false, reason: 'send-button-not-found' };
+      }
+
+      sendButton.click();
+      return { ok: true };
+    })()
+  `;
+}
+cli({
+    site: 'xianyu',
+    name: 'chat',
+    description: '打开闲鱼聊一聊会话，并可选发送消息',
+    domain: 'www.goofish.com',
+    strategy: Strategy.COOKIE,
+    navigateBefore: false,
+    browser: true,
+    args: [
+        { name: 'item_id', required: true, positional: true, help: '闲鱼商品 item_id' },
+        { name: 'user_id', required: true, positional: true, help: '聊一聊对方的 user_id / peerUserId' },
+        { name: 'text', help: 'Message to send after opening the chat' },
+    ],
+    columns: ['status', 'peer_name', 'item_title', 'price', 'location', 'message'],
+    func: async (page, kwargs) => {
+        const itemId = normalizeNumericId(kwargs.item_id, 'item_id', '1038951278192');
+        const userId = normalizeNumericId(kwargs.user_id, 'user_id', '3650092411');
+        const url = buildChatUrl(itemId, userId);
+        const text = String(kwargs.text || '').trim();
+        await page.goto(url);
+        await page.wait(2);
+        const state = await page.evaluate(buildExtractChatStateEvaluate());
+        if (state?.requiresAuth) {
+            throw new AuthRequiredError('www.goofish.com', 'Xianyu chat requires a logged-in browser session');
+        }
+        if (!state?.can_input) {
+            throw new SelectorError('闲鱼聊天输入框', '未找到可用的聊天输入框，请确认该会话页已正确加载');
+        }
+        if (!text) {
+            return [{
+                    status: 'ready',
+                    peer_name: state.peer_name || '',
+                    item_title: state.item_title || '',
+                    price: state.price || '',
+                    location: state.location || '',
+                    message: (state.visible_messages || []).slice(-1)[0] || '',
+                    peer_user_id: userId,
+                    item_id: itemId,
+                    url,
+                    item_url: state.item_url || '',
+                }];
+        }
+        const sent = await page.evaluate(buildSendMessageEvaluate(text));
+        if (!sent?.ok) {
+            throw new SelectorError('闲鱼发送按钮', `消息发送失败：${sent?.reason || 'unknown-reason'}`);
+        }
+        await page.wait(1);
+        return [{
+                status: 'sent',
+                peer_name: state.peer_name || '',
+                item_title: state.item_title || '',
+                price: state.price || '',
+                location: state.location || '',
+                message: text,
+                peer_user_id: userId,
+                item_id: itemId,
+                url,
+                item_url: state.item_url || '',
+            }];
+    },
+});
+export const __test__ = {
+    normalizeNumericId,
+    buildChatUrl,
+};

package/dist/clis/xianyu/chat.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/xianyu/chat.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './chat.js';
+describe('xianyu chat helpers', () => {
+    it('builds goofish im urls from ids', () => {
+        expect(__test__.buildChatUrl('1038951278192', '3650092411')).toBe('https://www.goofish.com/im?itemId=1038951278192&peerUserId=3650092411');
+    });
+    it('normalizes numeric ids', () => {
+        expect(__test__.normalizeNumericId('1038951278192', 'item_id', '1038951278192')).toBe('1038951278192');
+        expect(__test__.normalizeNumericId(3650092411, 'user_id', '3650092411')).toBe('3650092411');
+    });
+    it('rejects non-numeric ids', () => {
+        expect(() => __test__.normalizeNumericId('abc', 'item_id', '1038951278192')).toThrow();
+        expect(() => __test__.normalizeNumericId('3650092411x', 'user_id', '3650092411')).toThrow();
+    });
+});

package/dist/clis/xianyu/item.d.ts

@@ -0,0 +1,7 @@
+import { normalizeNumericId } from './utils.js';
+declare function buildItemUrl(itemId: string): string;
+export declare const __test__: {
+    normalizeNumericId: typeof normalizeNumericId;
+    buildItemUrl: typeof buildItemUrl;
+};
+export {};