@jackwener/opencli 1.5.4 → 1.5.6

package/src/clis/weread/book.ts

@@ -1,6 +1,82 @@
 import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
 import type { IPage } from '../../types.js';
-import { fetchPrivateApi } from './utils.js';
+import { fetchPrivateApi, resolveShelfReaderUrl } from './utils.js';
+
+interface ReaderFallbackResult {
+  title: string;
+  author: string;
+  publisher: string;
+  intro: string;
+  category: string;
+  rating: string;
+  metadataReady: boolean;
+}
+
+/**
+ * Read visible book metadata from the web reader cover/flyleaf page.
+ * This path is used as a fallback when the private API session has expired.
+ */
+async function loadReaderFallbackResult(page: IPage, readerUrl: string): Promise<ReaderFallbackResult> {
+  await page.goto(readerUrl);
+  await page.wait({ selector: '.horizontalReaderCoverPage_content_bookTitle, .wr_flyleaf_page_bookInfo_bookTitle', timeout: 10 });
+
+  const result = await page.evaluate(`
+    (() => {
+      const text = (node) => node?.textContent?.trim() || '';
+      const bodyText = document.body?.innerText?.replace(/\\s+/g, ' ').trim() || '';
+      const titleSelector = '.horizontalReaderCoverPage_content_bookTitle, .wr_flyleaf_page_bookInfo_bookTitle';
+      const authorSelector = '.horizontalReaderCoverPage_content_author, .wr_flyleaf_page_bookInfo_author';
+      const extractRating = () => {
+        const match = bodyText.match(/微信读书推荐值\\s*([0-9.]+%)/);
+        return match ? match[1] : '';
+      };
+      const extractPublisher = () => {
+        const direct = text(document.querySelector('.introDialog_content_pub_line'));
+        return direct.startsWith('出版社') ? direct.replace(/^出版社\\s*/, '').trim() : '';
+      };
+      const extractIntro = () => {
+        const selectors = [
+          '.horizontalReaderCoverPage_content_bookInfo_intro',
+          '.wr_flyleaf_page_bookIntro_content',
+          '.introDialog_content_intro_para',
+        ];
+        for (const selector of selectors) {
+          const value = text(document.querySelector(selector));
+          if (value) return value;
+        }
+        return '';
+      };
+
+      const categorySource = Array.from(document.scripts)
+        .map((script) => script.textContent || '')
+        .find((scriptText) => scriptText.includes('"category"')) || '';
+      const categoryMatch = categorySource.match(/"category"\\s*:\\s*"([^"]+)"/);
+      const title = text(document.querySelector(titleSelector));
+      const author = text(document.querySelector(authorSelector));
+
+      return {
+        title,
+        author,
+        publisher: extractPublisher(),
+        intro: extractIntro(),
+        category: categoryMatch ? categoryMatch[1].trim() : '',
+        rating: extractRating(),
+        metadataReady: Boolean(title || author),
+      };
+    })()
+  `) as Partial<ReaderFallbackResult>;
+
+  return {
+    title: String(result?.title || '').trim(),
+    author: String(result?.author || '').trim(),
+    publisher: String(result?.publisher || '').trim(),
+    intro: String(result?.intro || '').trim(),
+    category: String(result?.category || '').trim(),
+    rating: String(result?.rating || '').trim(),
+    metadataReady: result?.metadataReady === true,
+  };
+}
 
 cli({
   site: 'weread',
@@ -9,20 +85,47 @@ cli({
   domain: 'weread.qq.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'book-id', positional: true, required: true, help: 'Book ID (numeric, from search or shelf results)' },
+    { name: 'book-id', positional: true, required: true, help: 'Book ID from search or shelf results' },
   ],
   columns: ['title', 'author', 'publisher', 'intro', 'category', 'rating'],
   func: async (page: IPage, args) => {
-    const data = await fetchPrivateApi(page, '/book/info', { bookId: args['book-id'] });
-    // 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,
-    }];
+    const bookId = String(args['book-id'] || '').trim();
+
+    try {
+      const data = await fetchPrivateApi(page, '/book/info', { 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,
+      }];
+    } catch (error) {
+      if (!(error instanceof CliError) || error.code !== 'AUTH_REQUIRED') {
+        throw error;
+      }
+
+      const readerUrl = await resolveShelfReaderUrl(page, bookId);
+      if (!readerUrl) {
+        throw error;
+      }
+
+      const data = await loadReaderFallbackResult(page, readerUrl);
+      if (!data.metadataReady || !data.title) {
+        throw error;
+      }
+
+      return [{
+        title: data.title,
+        author: data.author,
+        publisher: data.publisher,
+        intro: data.intro,
+        category: data.category,
+        rating: data.rating,
+      }];
+    }
   },
 });

package/src/clis/weread/commands.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { CliError } from '../../errors.js';
 
 const { mockFetchPrivateApi } = vi.hoisted(() => ({
   mockFetchPrivateApi: vi.fn(),
@@ -34,6 +35,254 @@ describe('weread book-id positional args', () => {
     expect(mockFetchPrivateApi).toHaveBeenCalledWith({}, '/book/info', { bookId: '12345' });
   });
 
+  it('falls back to the shelf reader page when private API auth has expired', async () => {
+    mockFetchPrivateApi.mockRejectedValue(
+      new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first'),
+    );
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'MP_WXS_3634777637', title: '文明、现代化、价值投资与中国', author: '李录' },
+          ],
+          shelfIndexes: [
+            { bookId: 'MP_WXS_3634777637', idx: 0, role: 'book' },
+          ],
+        })
+        .mockResolvedValueOnce(['https://weread.qq.com/web/reader/6f5323f071bd7f7b6f521e8'])
+        .mockResolvedValueOnce({
+          title: '文明、现代化、价值投资与中国',
+          author: '李录',
+          publisher: '中信出版集团',
+          intro: '对中国未来几十年的预测。',
+          category: '',
+          rating: '84.1%',
+          metadataReady: true,
+        }),
+      getCookies: vi.fn().mockResolvedValue([
+        { name: 'wr_vid', value: '70486028', domain: '.weread.qq.com' },
+      ]),
+      wait: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    const result = await book!.func!(page, { 'book-id': 'MP_WXS_3634777637' });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://weread.qq.com/web/shelf');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://weread.qq.com/web/reader/6f5323f071bd7f7b6f521e8');
+    expect(page.evaluate).toHaveBeenCalledTimes(3);
+    expect(result).toEqual([
+      {
+        title: '文明、现代化、价值投资与中国',
+        author: '李录',
+        publisher: '中信出版集团',
+        intro: '对中国未来几十年的预测。',
+        category: '',
+        rating: '84.1%',
+      },
+    ]);
+  });
+
+  it('keeps mixed shelf entries aligned when resolving MP_WXS reader urls', async () => {
+    mockFetchPrivateApi.mockRejectedValue(
+      new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first'),
+    );
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'MP_WXS_1', title: '公众号文章一', author: '作者甲' },
+            { bookId: 'BOOK_2', title: '普通书二', author: '作者乙' },
+            { bookId: 'MP_WXS_3', title: '公众号文章三', author: '作者丙' },
+          ],
+          shelfIndexes: [
+            { bookId: 'MP_WXS_1', idx: 0, role: 'mp' },
+            { bookId: 'BOOK_2', idx: 1, role: 'book' },
+            { bookId: 'MP_WXS_3', idx: 2, role: 'mp' },
+          ],
+        })
+        .mockResolvedValueOnce([
+          'https://weread.qq.com/web/reader/mp1',
+          'https://weread.qq.com/web/reader/book2',
+          'https://weread.qq.com/web/reader/mp3',
+        ])
+        .mockResolvedValueOnce({
+          title: '公众号文章一',
+          author: '作者甲',
+          publisher: '微信读书',
+          intro: '第一篇文章。',
+          category: '',
+          rating: '',
+          metadataReady: true,
+        }),
+      getCookies: vi.fn().mockResolvedValue([
+        { name: 'wr_vid', value: '70486028', domain: '.weread.qq.com' },
+      ]),
+      wait: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    const result = await book!.func!(page, { 'book-id': 'MP_WXS_1' });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://weread.qq.com/web/shelf');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://weread.qq.com/web/reader/mp1');
+    expect(result).toEqual([
+      {
+        title: '公众号文章一',
+        author: '作者甲',
+        publisher: '微信读书',
+        intro: '第一篇文章。',
+        category: '',
+        rating: '',
+      },
+    ]);
+  });
+
+  it('rethrows AUTH_REQUIRED when shelf ordering is incomplete and reader urls cannot be trusted', async () => {
+    mockFetchPrivateApi.mockRejectedValue(
+      new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first'),
+    );
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'BOOK_1', title: '第一本', author: '作者甲' },
+            { bookId: 'BOOK_2', title: '第二本', author: '作者乙' },
+          ],
+          shelfIndexes: [
+            { bookId: 'BOOK_2', idx: 0, role: 'book' },
+          ],
+        })
+        .mockResolvedValueOnce([
+          'https://weread.qq.com/web/reader/book2',
+          'https://weread.qq.com/web/reader/book1',
+        ]),
+      getCookies: vi.fn().mockResolvedValue([
+        { name: 'wr_vid', value: '70486028', domain: '.weread.qq.com' },
+      ]),
+      wait: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    await expect(book!.func!(page, { 'book-id': 'BOOK_1' })).rejects.toMatchObject({
+      code: 'AUTH_REQUIRED',
+      message: 'Not logged in to WeRead',
+    });
+    expect(page.goto).toHaveBeenCalledTimes(1);
+    expect(page.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
+  });
+
+  it('waits for shelf indexes to hydrate before resolving a trusted reader url', async () => {
+    mockFetchPrivateApi.mockRejectedValue(
+      new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first'),
+    );
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'BOOK_1', title: '第一本', author: '作者甲' },
+            { bookId: 'BOOK_2', title: '第二本', author: '作者乙' },
+          ],
+          shelfIndexes: [
+            { bookId: 'BOOK_2', idx: 0, role: 'book' },
+          ],
+        })
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'BOOK_1', title: '第一本', author: '作者甲' },
+            { bookId: 'BOOK_2', title: '第二本', author: '作者乙' },
+          ],
+          shelfIndexes: [
+            { bookId: 'BOOK_2', idx: 0, role: 'book' },
+            { bookId: 'BOOK_1', idx: 1, role: 'book' },
+          ],
+        })
+        .mockResolvedValueOnce([
+          'https://weread.qq.com/web/reader/book2',
+          'https://weread.qq.com/web/reader/book1',
+        ])
+        .mockResolvedValueOnce({
+          title: '第一本',
+          author: '作者甲',
+          publisher: '出版社甲',
+          intro: '简介甲',
+          category: '',
+          rating: '',
+          metadataReady: true,
+        }),
+      getCookies: vi.fn().mockResolvedValue([
+        { name: 'wr_vid', value: '70486028', domain: '.weread.qq.com' },
+      ]),
+      wait: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    const result = await book!.func!(page, { 'book-id': 'BOOK_1' });
+
+    expect(page.goto).toHaveBeenNthCalledWith(1, 'https://weread.qq.com/web/shelf');
+    expect(page.goto).toHaveBeenNthCalledWith(2, 'https://weread.qq.com/web/reader/book1');
+    expect(result).toEqual([
+      {
+        title: '第一本',
+        author: '作者甲',
+        publisher: '出版社甲',
+        intro: '简介甲',
+        category: '',
+        rating: '',
+      },
+    ]);
+  });
+
+  it('rethrows AUTH_REQUIRED when the reader page lacks stable cover metadata', async () => {
+    mockFetchPrivateApi.mockRejectedValue(
+      new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first'),
+    );
+
+    const page = {
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn()
+        .mockResolvedValueOnce({
+          cacheFound: true,
+          rawBooks: [
+            { bookId: 'BOOK_1', title: '第一本', author: '作者甲' },
+          ],
+          shelfIndexes: [
+            { bookId: 'BOOK_1', idx: 0, role: 'book' },
+          ],
+        })
+        .mockResolvedValueOnce([
+          'https://weread.qq.com/web/reader/book1',
+        ])
+        .mockResolvedValueOnce({
+          title: '',
+          author: '',
+          publisher: '',
+          intro: '这是正文第一段，不应该被当成简介。',
+          category: '',
+          rating: '',
+          metadataReady: false,
+        }),
+      getCookies: vi.fn().mockResolvedValue([
+        { name: 'wr_vid', value: '70486028', domain: '.weread.qq.com' },
+      ]),
+      wait: vi.fn().mockResolvedValue(undefined),
+    } as any;
+
+    await expect(book!.func!(page, { 'book-id': 'BOOK_1' })).rejects.toMatchObject({
+      code: 'AUTH_REQUIRED',
+      message: 'Not logged in to WeRead',
+    });
+  });
+
   it('passes the positional book-id to highlights', async () => {
     mockFetchPrivateApi.mockResolvedValue({ updated: [] });
 

package/src/{weread-private-api-regression.test.ts → clis/weread/private-api-regression.test.ts}

@@ -1,7 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from './registry.js';
-import { fetchPrivateApi } from './clis/weread/utils.js';
-import './clis/weread/shelf.js';
+import { getRegistry } from '../../registry.js';
+import { log } from '../../logger.js';
+import { fetchPrivateApi } from './utils.js';
+import './shelf.js';
 
 describe('weread private API regression', () => {
   beforeEach(() => {
@@ -12,8 +13,10 @@ describe('weread private API regression', () => {
     const mockPage = {
       getCookies: vi.fn()
         .mockResolvedValueOnce([
-          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
           { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+        ])
+        .mockResolvedValueOnce([
+          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
         ]),
       evaluate: vi.fn(),
     } as any;
@@ -28,8 +31,9 @@ describe('weread private API regression', () => {
     const result = await fetchPrivateApi(mockPage, '/book/info', { bookId: '123' });
 
     expect(result.title).toBe('Test Book');
-    expect(mockPage.getCookies).toHaveBeenCalledTimes(1);
+    expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
     expect(mockPage.getCookies).toHaveBeenCalledWith({ url: 'https://i.weread.qq.com/book/info?bookId=123' });
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
     expect(mockPage.evaluate).not.toHaveBeenCalled();
     expect(fetchMock).toHaveBeenCalledWith(
       'https://i.weread.qq.com/book/info?bookId=123',
@@ -41,6 +45,72 @@ describe('weread private API regression', () => {
     );
   });
 
+  it('merges host-only main-domain cookies into private API requests', async () => {
+    // Simulates host-only cookies on weread.qq.com that don't match i.weread.qq.com by URL
+    const mockPage = {
+      getCookies: vi.fn()
+        .mockResolvedValueOnce([])  // URL lookup returns nothing for i.weread.qq.com
+        .mockResolvedValueOnce([
+          { name: 'wr_skey', value: 'skey-host', domain: 'weread.qq.com' },
+          { name: 'wr_vid', value: 'vid-host', domain: 'weread.qq.com' },
+        ]),
+      evaluate: vi.fn(),
+    } as any;
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ title: 'Book', errcode: 0 }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await fetchPrivateApi(mockPage, '/book/info', { bookId: '42' });
+
+    expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ url: 'https://i.weread.qq.com/book/info?bookId=42' });
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://i.weread.qq.com/book/info?bookId=42',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Cookie: 'wr_skey=skey-host; wr_vid=vid-host',
+        }),
+      }),
+    );
+  });
+
+  it('prefers API-subdomain cookies over main-domain cookies on name collision', async () => {
+    const mockPage = {
+      getCookies: vi.fn()
+        .mockResolvedValueOnce([
+          { name: 'wr_skey', value: 'from-api', domain: 'i.weread.qq.com' },
+        ])
+        .mockResolvedValueOnce([
+          { name: 'wr_skey', value: 'from-main', domain: 'weread.qq.com' },
+          { name: 'wr_vid', value: 'vid-main', domain: 'weread.qq.com' },
+        ]),
+      evaluate: vi.fn(),
+    } as any;
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ title: 'Book', errcode: 0 }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await fetchPrivateApi(mockPage, '/book/info', { bookId: '99' });
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://i.weread.qq.com/book/info?bookId=99',
+      expect.objectContaining({
+        headers: expect.objectContaining({
+          Cookie: 'wr_skey=from-api; wr_vid=vid-main',
+        }),
+      }),
+    );
+  });
+
   it('maps unauthenticated private API responses to AUTH_REQUIRED', async () => {
     const mockPage = {
       getCookies: vi.fn().mockResolvedValue([]),
@@ -126,8 +196,10 @@ describe('weread private API regression', () => {
     const mockPage = {
       getCookies: vi.fn()
         .mockResolvedValueOnce([
-          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
           { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+        ])
+        .mockResolvedValueOnce([
+          { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
         ]),
       evaluate: vi.fn(),
     } as any;
@@ -153,9 +225,11 @@ describe('weread private API regression', () => {
       'https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0',
       expect.any(Object),
     );
+    expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
     expect(mockPage.getCookies).toHaveBeenCalledWith({
       url: 'https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0',
     });
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
     expect(result).toEqual([
       {
         title: 'Deep Work',
@@ -169,15 +243,16 @@ describe('weread private API regression', () => {
   it('falls back to structured shelf cache when the private API reports AUTH_REQUIRED', async () => {
     const command = getRegistry().get('weread/shelf');
     expect(command?.func).toBeTypeOf('function');
+    const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => {});
 
     const mockPage = {
       getCookies: vi.fn()
-        .mockResolvedValueOnce([
-          { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-        ])
-        .mockResolvedValueOnce([
-          { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-        ]),
+        // fetchPrivateApi: URL lookup (i.weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // fetchPrivateApi: domain lookup (weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // loadWebShelfSnapshot: domain lookup for wr_vid
+        .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
       goto: vi.fn().mockResolvedValue(undefined),
       evaluate: vi.fn().mockImplementation(async (source: string) => {
         expect(source).toContain('shelf:rawBooks:vid-current');
@@ -219,6 +294,9 @@ describe('weread private API regression', () => {
     expect(mockPage.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
     expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
     expect(mockPage.evaluate).toHaveBeenCalledTimes(1);
+    expect(warnSpy).toHaveBeenCalledWith(
+      'WeRead private API auth expired; showing cached shelf data from localStorage. Results may be stale, and detail commands may still require re-login.',
+    );
     expect(result).toEqual([
       {
         title: '文明、现代化、价值投资与中国',
@@ -235,12 +313,12 @@ describe('weread private API regression', () => {
 
     const mockPage = {
       getCookies: vi.fn()
-        .mockResolvedValueOnce([
-          { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-        ])
-        .mockResolvedValueOnce([
-          { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-        ]),
+        // fetchPrivateApi: URL lookup (i.weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // fetchPrivateApi: domain lookup (weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // loadWebShelfSnapshot: domain lookup for wr_vid
+        .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
       goto: vi.fn().mockResolvedValue(undefined),
       evaluate: vi.fn().mockResolvedValue({
         cacheFound: false,
@@ -270,12 +348,12 @@ describe('weread private API regression', () => {
 
     const mockPage = {
       getCookies: vi.fn()
-        .mockResolvedValueOnce([
-          { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-        ])
-        .mockResolvedValueOnce([
-          { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-        ]),
+        // fetchPrivateApi: URL lookup (i.weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // fetchPrivateApi: domain lookup (weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // loadWebShelfSnapshot: domain lookup for wr_vid
+        .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
       goto: vi.fn().mockResolvedValue(undefined),
       evaluate: vi.fn().mockResolvedValue({
         cacheFound: true,
@@ -304,12 +382,12 @@ describe('weread private API regression', () => {
 
     const mockPage = {
       getCookies: vi.fn()
-        .mockResolvedValueOnce([
-          { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-        ])
-        .mockResolvedValueOnce([
-          { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-        ]),
+        // fetchPrivateApi: URL lookup (i.weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // fetchPrivateApi: domain lookup (weread.qq.com)
+        .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+        // loadWebShelfSnapshot: domain lookup for wr_vid
+        .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
       goto: vi.fn().mockResolvedValue(undefined),
       evaluate: vi.fn().mockResolvedValue({
         cacheFound: true,