@jackwener/opencli 1.0.0 → 1.0.3

package/dist/clis/twitter/reply-dm.js

@@ -0,0 +1,181 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'reply-dm',
+    description: 'Send a message to recent DM conversations',
+    domain: 'x.com',
+    strategy: Strategy.UI,
+    browser: true,
+    timeoutSeconds: 600, // 10 min — batch operation
+    args: [
+        { name: 'text', type: 'string', required: 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)' },
+    ],
+    columns: ['index', 'status', 'user', 'message'],
+    func: async (page, kwargs) => {
+        if (!page)
+            throw new Error('Requires browser');
+        const messageText = kwargs.text;
+        const maxSend = kwargs.max ?? 20;
+        const skipReplied = kwargs['skip-replied'] !== false;
+        const results = [];
+        let sentCount = 0;
+        // Step 1: Navigate to messages to get conversation list
+        await page.goto('https://x.com/messages');
+        await page.wait(5);
+        // Step 2: Collect conversations with scroll-to-load
+        const needed = maxSend + 10; // extra buffer for skips
+        const convList = await page.evaluate(`(async () => {
+      try {
+        // Wait for initial items
+        let attempts = 0;
+        while (attempts < 10) {
+          const items = document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]');
+          if (items.length > 0) break;
+          await new Promise(r => setTimeout(r, 1000));
+          attempts++;
+        }
+
+        // Scroll to load more conversations
+        const needed = ${needed};
+        const seenIds = new Set();
+        let noNewCount = 0;
+
+        for (let scroll = 0; scroll < 30; scroll++) {
+          const items = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          items.forEach(el => seenIds.add(el.getAttribute('data-testid')));
+
+          if (seenIds.size >= needed) break;
+
+          // Find the scrollable container and scroll it
+          const scrollContainer = document.querySelector('[data-testid="dm-inbox-panel"]') ||
+                                  items[items.length - 1]?.closest('[class*="scroll"]') ||
+                                  items[items.length - 1]?.parentElement;
+          if (scrollContainer) {
+            scrollContainer.scrollTop = scrollContainer.scrollHeight;
+          }
+          // Also try scrolling the last item into view
+          if (items.length > 0) {
+            items[items.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+          }
+
+          await new Promise(r => setTimeout(r, 1500));
+
+          // Check if new items appeared
+          const newItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          const newIds = new Set(newItems.map(el => el.getAttribute('data-testid')));
+          if (newIds.size <= seenIds.size) {
+            noNewCount++;
+            if (noNewCount >= 3) break; // No more loading after 3 tries
+          } else {
+            noNewCount = 0;
+          }
+        }
+
+        // Collect all visible conversations
+        const finalItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+        const conversations = finalItems.map((item, idx) => {
+          const testId = item.getAttribute('data-testid') || '';
+          const text = item.innerText || '';
+          const lines = text.split('\\n').filter(l => l.trim());
+          const user = lines[0] || 'Unknown';
+          const match = testId.match(/dm-conversation-item-(.+)/);
+          const convId = match ? match[1].replace(':', '-') : '';
+          const link = item.querySelector('a[href*="/messages/"]');
+          const href = link ? link.href : '';
+          return { idx, user, convId, href, preview: text.substring(0, 100) };
+        });
+
+        return { ok: true, conversations, total: conversations.length };
+      } catch(e) {
+        return { ok: false, error: String(e), conversations: [], total: 0 };
+      }
+    })()`);
+        if (!convList?.ok || !convList.conversations?.length) {
+            return [{ index: 1, status: 'info', user: 'System', message: 'No conversations found' }];
+        }
+        const conversations = convList.conversations;
+        // Step 3: Iterate through conversations and send message
+        for (const conv of conversations) {
+            if (sentCount >= maxSend)
+                break;
+            const convUrl = conv.convId
+                ? `https://x.com/messages/${conv.convId}`
+                : conv.href;
+            if (!convUrl)
+                continue;
+            await page.goto(convUrl);
+            await page.wait(3);
+            const sendResult = await page.evaluate(`(async () => {
+        try {
+          const messageText = ${JSON.stringify(messageText)};
+          const skipReplied = ${skipReplied};
+
+          // Get username from conversation
+          const dmHeader = document.querySelector('[data-testid="DmActivityContainer"] [dir="ltr"] span') ||
+                           document.querySelector('[data-testid="conversation-header"]') ||
+                           document.querySelector('[data-testid="DmActivityContainer"] h2');
+          const username = dmHeader ? dmHeader.innerText.trim().split('\\\\n')[0] : '${conv.user}';
+
+          // Check if we already sent this message
+          if (skipReplied) {
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('main');
+            const chatText = chatArea ? chatArea.innerText : '';
+            if (chatText.includes(messageText)) {
+              return { status: 'skipped', user: username, message: 'Already sent this message' };
+            }
+          }
+
+          // Find the text input
+          const input = document.querySelector('[data-testid="dmComposerTextInput"]');
+          if (!input) {
+            return { status: 'error', user: username, message: 'No message input found' };
+          }
+
+          // Focus and type into the DraftEditor
+          input.focus();
+          await new Promise(r => setTimeout(r, 300));
+          document.execCommand('insertText', false, messageText);
+          await new Promise(r => setTimeout(r, 500));
+
+          // Click send button
+          const sendBtn = document.querySelector('[data-testid="dmComposerSendButton"]');
+          if (!sendBtn) {
+            return { status: 'error', user: username, message: 'No send button found' };
+          }
+
+          sendBtn.click();
+          await new Promise(r => setTimeout(r, 1500));
+
+          return { status: 'sent', user: username, message: 'Message sent: ' + messageText };
+        } catch(e) {
+          return { status: 'error', user: 'system', message: String(e) };
+        }
+      })()`);
+            if (sendResult?.status === 'sent') {
+                sentCount++;
+                results.push({
+                    index: sentCount,
+                    status: 'sent',
+                    user: sendResult.user || conv.user,
+                    message: sendResult.message,
+                });
+            }
+            else if (sendResult?.status === 'skipped') {
+                results.push({
+                    index: results.length + 1,
+                    status: 'skipped',
+                    user: sendResult.user || conv.user,
+                    message: sendResult.message,
+                });
+            }
+            await page.wait(1);
+        }
+        if (results.length === 0) {
+            results.push({ index: 0, status: 'info', user: 'System', message: 'No conversations processed' });
+        }
+        return results;
+    }
+});

package/dist/clis/twitter/search.js

@@ -12,18 +12,35 @@ cli({
     ],
     columns: ['id', 'author', 'text', 'likes', 'views', 'url'],
     func: async (page, kwargs) => {
-        // Install the interceptor before opening the target page so we don't miss
-        // the initial SearchTimeline request fired during hydration.
-        await page.goto('https://x.com');
-        await page.wait(2);
+        const query = kwargs.query;
+        // 1. Navigate to x.com/explore (has a search input at the top)
+        await page.goto('https://x.com/explore');
+        await page.wait(3);
+        // 2. Install interceptor BEFORE triggering search.
+        //    SPA navigation preserves the JS context, so the monkey-patched
+        //    fetch will capture the SearchTimeline API call.
         await page.installInterceptor('SearchTimeline');
-        // 1. Navigate to the search page
-        const q = encodeURIComponent(kwargs.query);
-        await page.goto(`https://x.com/search?q=${q}&f=top`);
+        // 3. Trigger SPA navigation to search results via history API.
+        //    pushState + popstate triggers React Router's listener without
+        //    a full page reload, so the interceptor stays alive.
+        //    Note: the previous approach (nativeSetter + Enter keydown on the
+        //    search input) does not reliably trigger Twitter's form submission.
+        const searchUrl = JSON.stringify(`/search?q=${encodeURIComponent(query)}&f=top`);
+        await page.evaluate(`
+      (() => {
+        window.history.pushState({}, '', ${searchUrl});
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+      })()
+    `);
         await page.wait(5);
-        // 3. Trigger API by scrolling
+        // Verify SPA navigation succeeded
+        const currentPath = await page.evaluate('() => window.location.pathname');
+        if (!currentPath?.startsWith('/search')) {
+            throw new Error('SPA navigation to /search failed. Twitter may have changed its routing.');
+        }
+        // 4. Scroll to trigger additional pagination
         await page.autoScroll({ times: 3, delayMs: 2000 });
-        // 4. Retrieve data
+        // 6. Retrieve captured data
         const requests = await page.getInterceptedRequests();
         if (!requests || requests.length === 0)
             return [];
@@ -31,7 +48,7 @@ cli({
         const seen = new Set();
         for (const req of requests) {
             try {
-                const insts = req.data?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
+                const insts = req?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
                 const addEntries = insts.find((i) => i.type === 'TimelineAddEntries')
                     || insts.find((i) => i.entries && Array.isArray(i.entries));
                 if (!addEntries?.entries)
@@ -49,9 +66,11 @@ cli({
                     if (!tweet.rest_id || seen.has(tweet.rest_id))
                         continue;
                     seen.add(tweet.rest_id);
+                    // Twitter moved screen_name from legacy to core
+                    const tweetUser = tweet.core?.user_results?.result;
                     results.push({
                         id: tweet.rest_id,
-                        author: tweet.core?.user_results?.result?.legacy?.screen_name || 'unknown',
+                        author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown',
                         text: tweet.note_tweet?.note_tweet_results?.result?.text || tweet.legacy?.full_text || '',
                         likes: tweet.legacy?.favorite_count || 0,
                         views: tweet.views?.count || '0',

package/dist/clis/weread/book.d.ts

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

package/dist/clis/weread/book.js

@@ -0,0 +1,26 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWithPage } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'book',
+    description: 'View book details on WeRead',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'bookId', positional: true, required: true, help: 'Book ID (numeric, from search or shelf results)' },
+    ],
+    columns: ['title', 'author', 'publisher', 'intro', 'category', 'rating'],
+    func: async (page, args) => {
+        const data = await fetchWithPage(page, '/book/info', { bookId: args.bookId });
+        // newRating is 0-1000 scale per community docs; needs runtime verification
+        const rating = data.newRating ? `${(data.newRating / 10).toFixed(1)}%` : '-';
+        return [{
+                title: data.title ?? '',
+                author: data.author ?? '',
+                publisher: data.publisher ?? '',
+                intro: data.intro ?? '',
+                category: data.category ?? '',
+                rating,
+            }];
+    },
+});

package/dist/clis/weread/highlights.d.ts

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

package/dist/clis/weread/highlights.js

@@ -0,0 +1,23 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWithPage, formatDate } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'highlights',
+    description: 'List your highlights (underlines) in a book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'bookId', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['chapter', 'text', 'createTime'],
+    func: async (page, args) => {
+        const data = await fetchWithPage(page, '/book/bookmarklist', { bookId: args.bookId });
+        const items = data?.updated ?? [];
+        return items.slice(0, Number(args.limit)).map((item) => ({
+            chapter: item.chapterName ?? '',
+            text: item.markText ?? '',
+            createTime: formatDate(item.createTime),
+        }));
+    },
+});

package/dist/clis/weread/notebooks.d.ts

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

package/dist/clis/weread/notebooks.js

@@ -0,0 +1,21 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWithPage } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'notebooks',
+    description: 'List books that have highlights or notes',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    columns: ['title', 'author', 'noteCount', 'bookId'],
+    func: async (page, _args) => {
+        const data = await fetchWithPage(page, '/user/notebooks');
+        const books = data?.books ?? [];
+        return books.map((item) => ({
+            title: item.book?.title ?? '',
+            author: item.book?.author ?? '',
+            // TODO: bookmarkCount/reviewCount field names from community docs, verify with real API
+            noteCount: (item.bookmarkCount ?? 0) + (item.reviewCount ?? 0),
+            bookId: item.bookId ?? '',
+        }));
+    },
+});

package/dist/clis/weread/notes.d.ts

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

package/dist/clis/weread/notes.js

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWithPage, formatDate } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'notes',
+    description: 'List your notes (thoughts) on a book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'bookId', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['chapter', 'text', 'review', 'createTime'],
+    func: async (page, args) => {
+        const data = await fetchWithPage(page, '/review/list', {
+            bookId: args.bookId,
+            listType: '11',
+            mine: '1',
+            synckey: '0',
+        });
+        const items = data?.reviews ?? [];
+        return items.slice(0, Number(args.limit)).map((item) => ({
+            chapter: item.review?.chapterName ?? '',
+            text: item.review?.abstract ?? '',
+            review: item.review?.content ?? '',
+            createTime: formatDate(item.review?.createTime),
+        }));
+    },
+});

package/dist/clis/weread/ranking.d.ts

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

package/dist/clis/weread/ranking.js

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWebApi } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'ranking',
+    description: 'WeRead book rankings by category',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'category', positional: true, default: 'all', help: 'Category: all (default), rising, or numeric category ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['rank', 'title', 'author', 'category', 'readingCount', 'bookId'],
+    func: async (_page, args) => {
+        const cat = encodeURIComponent(args.category ?? 'all');
+        const data = await fetchWebApi(`/bookListInCategory/${cat}`, { rank: '1' });
+        const books = data?.books ?? [];
+        return books.slice(0, Number(args.limit)).map((item, i) => ({
+            rank: i + 1,
+            title: item.bookInfo?.title ?? '',
+            author: item.bookInfo?.author ?? '',
+            category: item.bookInfo?.category ?? '',
+            readingCount: item.readingCount ?? 0,
+            bookId: item.bookInfo?.bookId ?? '',
+        }));
+    },
+});

package/dist/clis/weread/search.d.ts

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

package/dist/clis/weread/search.js

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWebApi } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'search',
+    description: 'Search books on WeRead',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max results' },
+    ],
+    columns: ['rank', 'title', 'author', 'bookId'],
+    func: async (_page, args) => {
+        const data = await fetchWebApi('/search/global', { keyword: args.keyword });
+        const books = data?.books ?? [];
+        return books.slice(0, Number(args.limit)).map((item, i) => ({
+            rank: i + 1,
+            title: item.bookInfo?.title ?? '',
+            author: item.bookInfo?.author ?? '',
+            bookId: item.bookInfo?.bookId ?? '',
+        }));
+    },
+});

package/dist/clis/weread/shelf.d.ts

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

package/dist/clis/weread/shelf.js

@@ -0,0 +1,24 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWithPage } from './utils.js';
+cli({
+    site: 'weread',
+    name: 'shelf',
+    description: 'List books on your WeRead bookshelf',
+    domain: 'weread.qq.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+    ],
+    columns: ['title', 'author', 'progress', 'bookId'],
+    func: async (page, args) => {
+        const data = await fetchWithPage(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
+        const books = data?.books ?? [];
+        return books.slice(0, Number(args.limit)).map((item) => ({
+            title: item.bookInfo?.title ?? item.title ?? '',
+            author: item.bookInfo?.author ?? item.author ?? '',
+            // TODO: readingProgress field name from community docs, verify with real API response
+            progress: item.readingProgress != null ? `${item.readingProgress}%` : '-',
+            bookId: item.bookId ?? item.bookInfo?.bookId ?? '',
+        }));
+    },
+});

package/dist/clis/weread/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * WeRead shared helpers: fetch wrappers and formatting.
+ *
+ * Two API domains:
+ * - WEB_API (weread.qq.com/web/*): public, Node.js fetch
+ * - API (i.weread.qq.com/*): private, browser page.evaluate with cookies
+ */
+import type { IPage } from '../../types.js';
+/**
+ * Fetch a public WeRead web endpoint (Node.js direct fetch).
+ * Used by search and ranking commands (browser: false).
+ */
+export declare function fetchWebApi(path: string, params?: Record<string, string>): Promise<any>;
+/**
+ * Fetch a private WeRead API endpoint via browser page.evaluate.
+ * Automatically carries cookies for authenticated requests.
+ */
+export declare function fetchWithPage(page: IPage, path: string, params?: Record<string, string>): Promise<any>;
+/** Format a Unix timestamp (seconds) to YYYY-MM-DD in UTC+8. Returns '-' for invalid input. */
+export declare function formatDate(ts: number | undefined | null): string;

package/dist/clis/weread/utils.js

@@ -0,0 +1,72 @@
+/**
+ * WeRead shared helpers: fetch wrappers and formatting.
+ *
+ * Two API domains:
+ * - WEB_API (weread.qq.com/web/*): public, Node.js fetch
+ * - API (i.weread.qq.com/*): private, browser page.evaluate with cookies
+ */
+import { CliError } from '../../errors.js';
+const WEB_API = 'https://weread.qq.com/web';
+const API = 'https://i.weread.qq.com';
+const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+/**
+ * Fetch a public WeRead web endpoint (Node.js direct fetch).
+ * Used by search and ranking commands (browser: false).
+ */
+export async function fetchWebApi(path, params) {
+    const url = new URL(`${WEB_API}${path}`);
+    if (params) {
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+    }
+    const resp = await fetch(url.toString(), {
+        headers: { 'User-Agent': UA },
+    });
+    if (!resp.ok) {
+        throw new CliError('FETCH_ERROR', `HTTP ${resp.status} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    try {
+        return await resp.json();
+    }
+    catch {
+        throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
+    }
+}
+/**
+ * Fetch a private WeRead API endpoint via browser page.evaluate.
+ * Automatically carries cookies for authenticated requests.
+ */
+export async function fetchWithPage(page, path, params) {
+    const url = new URL(`${API}${path}`);
+    if (params) {
+        for (const [k, v] of Object.entries(params))
+            url.searchParams.set(k, v);
+    }
+    const urlStr = url.toString();
+    const data = await page.evaluate(`
+    async () => {
+      const res = await fetch(${JSON.stringify(urlStr)}, { credentials: "include" });
+      if (!res.ok) return { _httpError: String(res.status) };
+      try { return await res.json(); }
+      catch { return { _httpError: 'JSON parse error (status ' + res.status + ')' }; }
+    }
+  `);
+    if (data?._httpError) {
+        throw new CliError('FETCH_ERROR', `HTTP ${data._httpError} for ${path}`, 'WeRead API may be temporarily unavailable');
+    }
+    if (data?.errcode === -2010) {
+        throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
+    }
+    if (data?.errcode != null && data.errcode !== 0) {
+        throw new CliError('API_ERROR', data.errmsg ?? `WeRead API error ${data.errcode}`);
+    }
+    return data;
+}
+/** Format a Unix timestamp (seconds) to YYYY-MM-DD in UTC+8. Returns '-' for invalid input. */
+export function formatDate(ts) {
+    if (!Number.isFinite(ts) || ts <= 0)
+        return '-';
+    // WeRead timestamps are China-centric; offset to UTC+8 to avoid off-by-one near midnight
+    const d = new Date(ts * 1000 + 8 * 3600_000);
+    return d.toISOString().slice(0, 10);
+}

package/dist/clis/weread/utils.test.d.ts

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

package/dist/clis/weread/utils.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { formatDate, fetchWebApi, fetchWithPage } from './utils.js';
+describe('formatDate', () => {
+    it('formats a typical Unix timestamp in UTC+8', () => {
+        // 1705276800 = 2024-01-15 00:00:00 UTC = 2024-01-15 08:00:00 Beijing
+        expect(formatDate(1705276800)).toBe('2024-01-15');
+    });
+    it('handles UTC midnight edge case with UTC+8 offset', () => {
+        // 1705190399 = 2024-01-13 23:59:59 UTC = 2024-01-14 07:59:59 Beijing
+        expect(formatDate(1705190399)).toBe('2024-01-14');
+    });
+    it('returns dash for zero', () => {
+        expect(formatDate(0)).toBe('-');
+    });
+    it('returns dash for negative', () => {
+        expect(formatDate(-1)).toBe('-');
+    });
+    it('returns dash for NaN', () => {
+        expect(formatDate(NaN)).toBe('-');
+    });
+    it('returns dash for Infinity', () => {
+        expect(formatDate(Infinity)).toBe('-');
+    });
+    it('returns dash for undefined', () => {
+        expect(formatDate(undefined)).toBe('-');
+    });
+    it('returns dash for null', () => {
+        expect(formatDate(null)).toBe('-');
+    });
+});
+describe('fetchWebApi', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('returns parsed JSON for successful response', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({ books: [{ title: 'Test' }] }),
+        }));
+        const result = await fetchWebApi('/search/global', { keyword: 'test' });
+        expect(result).toEqual({ books: [{ title: 'Test' }] });
+    });
+    it('throws CliError on HTTP error', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: false,
+            status: 403,
+            json: () => Promise.resolve({}),
+        }));
+        await expect(fetchWebApi('/search/global')).rejects.toThrow('HTTP 403');
+    });
+    it('throws PARSE_ERROR on non-JSON response', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.reject(new SyntaxError('Unexpected token <')),
+        }));
+        await expect(fetchWebApi('/search/global')).rejects.toThrow('Invalid JSON');
+    });
+});
+describe('fetchWithPage', () => {
+    it('throws AUTH_REQUIRED on errcode -2010', async () => {
+        const mockPage = {
+            evaluate: vi.fn().mockResolvedValue({ errcode: -2010, errmsg: '用户不存在' }),
+        };
+        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('Not logged in');
+    });
+    it('throws API_ERROR on unknown errcode', async () => {
+        const mockPage = {
+            evaluate: vi.fn().mockResolvedValue({ errcode: -1, errmsg: 'unknown error' }),
+        };
+        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('unknown error');
+    });
+    it('returns data on success (errcode 0 or absent)', async () => {
+        const mockPage = {
+            evaluate: vi.fn().mockResolvedValue({ title: 'Test Book', errcode: 0 }),
+        };
+        const result = await fetchWithPage(mockPage, '/book/info');
+        expect(result.title).toBe('Test Book');
+    });
+    it('throws FETCH_ERROR on HTTP error', async () => {
+        const mockPage = {
+            evaluate: vi.fn().mockResolvedValue({ _httpError: '403' }),
+        };
+        await expect(fetchWithPage(mockPage, '/book/info')).rejects.toThrow('HTTP 403');
+    });
+});

package/dist/clis/xiaohongshu/download.d.ts

@@ -2,6 +2,6 @@
  * Xiaohongshu download — download images and videos from a note.
  *
  * Usage:
- *   opencli xiaohongshu download --note-id abc123 --output ./xhs
+ *   opencli xiaohongshu download --note_id abc123 --output ./xhs
  */
 export {};

package/dist/clis/xiaohongshu/download.js

@@ -2,7 +2,7 @@
  * Xiaohongshu download — download images and videos from a note.
  *
  * Usage:
- *   opencli xiaohongshu download --note-id abc123 --output ./xhs
+ *   opencli xiaohongshu download --note_id abc123 --output ./xhs
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';