@jackwener/opencli 1.5.1 → 1.5.2

package/src/clis/weread/shelf.ts

@@ -1,7 +1,159 @@
 import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
 import type { IPage } from '../../types.js';
 import { fetchPrivateApi } from './utils.js';
 
+const WEREAD_DOMAIN = 'weread.qq.com';
+const WEREAD_SHELF_URL = `https://${WEREAD_DOMAIN}/web/shelf`;
+
+interface ShelfRow {
+  title: string;
+  author: string;
+  progress: string;
+  bookId: string;
+}
+
+interface WebShelfRawBook {
+  bookId?: string;
+  title?: string;
+  author?: string;
+}
+
+interface WebShelfIndexEntry {
+  bookId?: string;
+  idx?: number;
+  role?: string;
+}
+
+interface WebShelfSnapshot {
+  cacheFound: boolean;
+  rawBooks: WebShelfRawBook[];
+  shelfIndexes: WebShelfIndexEntry[];
+}
+
+function normalizeShelfLimit(limit: number): number {
+  if (!Number.isFinite(limit)) return 0;
+  return Math.max(0, Math.trunc(limit));
+}
+
+function normalizePrivateApiRows(data: any, limit: number): ShelfRow[] {
+  const books: any[] = data?.books ?? [];
+  return books.slice(0, limit).map((item: any) => ({
+    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 ?? '',
+  }));
+}
+
+function normalizeWebShelfRows(snapshot: WebShelfSnapshot, limit: number): ShelfRow[] {
+  if (limit <= 0) return [];
+
+  const bookById = new Map<string, WebShelfRawBook>();
+  for (const book of snapshot.rawBooks) {
+    const bookId = String(book?.bookId || '').trim();
+    if (!bookId) continue;
+    bookById.set(bookId, book);
+  }
+
+  const orderedBookIds = snapshot.shelfIndexes
+    .filter((entry) => String(entry?.role || 'book') === 'book')
+    .sort((left, right) => Number(left?.idx ?? Number.MAX_SAFE_INTEGER) - Number(right?.idx ?? Number.MAX_SAFE_INTEGER))
+    .map((entry) => String(entry?.bookId || '').trim())
+    .filter(Boolean);
+
+  const fallbackOrder = snapshot.rawBooks
+    .map((book) => String(book?.bookId || '').trim())
+    .filter(Boolean);
+
+  const orderedUniqueBookIds = Array.from(new Set([
+    ...orderedBookIds,
+    ...fallbackOrder,
+  ]));
+
+  return orderedUniqueBookIds
+    .map((bookId) => {
+      const book = bookById.get(bookId);
+      if (!book) return null;
+      return {
+        title: String(book.title || '').trim(),
+        author: String(book.author || '').trim(),
+        progress: '-',
+        bookId,
+      } satisfies ShelfRow;
+    })
+    .filter((item): item is ShelfRow => Boolean(item && (item.title || item.bookId)))
+    .slice(0, limit);
+}
+
+/**
+ * Read the structured shelf cache from the web shelf page.
+ * The page hydrates localStorage with raw book data plus shelf ordering.
+ */
+async function loadWebShelfSnapshot(page: IPage): Promise<WebShelfSnapshot> {
+  await page.goto(WEREAD_SHELF_URL);
+
+  const cookies = await page.getCookies({ domain: WEREAD_DOMAIN });
+  const currentVid = String(cookies.find((cookie) => cookie.name === 'wr_vid')?.value || '').trim();
+
+  if (!currentVid) {
+    return { cacheFound: false, rawBooks: [], shelfIndexes: [] };
+  }
+
+  const rawBooksKey = `shelf:rawBooks:${currentVid}`;
+  const shelfIndexesKey = `shelf:shelfIndexes:${currentVid}`;
+
+  const result = await page.evaluate(`
+    (() => new Promise((resolve) => {
+      const deadline = Date.now() + 5000;
+      const rawBooksKey = ${JSON.stringify(rawBooksKey)};
+      const shelfIndexesKey = ${JSON.stringify(shelfIndexesKey)};
+
+      const readJson = (raw) => {
+        if (typeof raw !== 'string') return null;
+        try {
+          return JSON.parse(raw);
+        } catch {
+          return null;
+        }
+      };
+
+      const poll = () => {
+        const rawBooksRaw = localStorage.getItem(rawBooksKey);
+        const shelfIndexesRaw = localStorage.getItem(shelfIndexesKey);
+        const rawBooks = readJson(rawBooksRaw);
+        const shelfIndexes = readJson(shelfIndexesRaw);
+        const cacheFound = Array.isArray(rawBooks);
+
+        if (cacheFound || Date.now() >= deadline) {
+          resolve({
+            cacheFound,
+            rawBooks: Array.isArray(rawBooks) ? rawBooks : [],
+            shelfIndexes: Array.isArray(shelfIndexes) ? shelfIndexes : [],
+          });
+          return;
+        }
+
+        setTimeout(poll, 100);
+      };
+
+      poll();
+    }))
+  `);
+
+  if (!result || typeof result !== 'object') {
+    return { cacheFound: false, rawBooks: [], shelfIndexes: [] };
+  }
+
+  const snapshot = result as Partial<WebShelfSnapshot>;
+  return {
+    cacheFound: snapshot.cacheFound === true,
+    rawBooks: Array.isArray(snapshot.rawBooks) ? snapshot.rawBooks : [],
+    shelfIndexes: Array.isArray(snapshot.shelfIndexes) ? snapshot.shelfIndexes : [],
+  };
+}
+
 cli({
   site: 'weread',
   name: 'shelf',
@@ -13,14 +165,22 @@ cli({
   ],
   columns: ['title', 'author', 'progress', 'bookId'],
   func: async (page: IPage, args) => {
-    const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
-    const books: any[] = data?.books ?? [];
-    return books.slice(0, Number(args.limit)).map((item: any) => ({
-      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 ?? '',
-    }));
+    const limit = normalizeShelfLimit(Number(args.limit));
+    if (limit <= 0) return [];
+
+    try {
+      const data = await fetchPrivateApi(page, '/shelf/sync', { synckey: '0', lectureSynckey: '0' });
+      return normalizePrivateApiRows(data, limit);
+    } catch (error) {
+      if (!(error instanceof CliError) || error.code !== 'AUTH_REQUIRED') {
+        throw error;
+      }
+
+      const snapshot = await loadWebShelfSnapshot(page);
+      if (!snapshot.cacheFound) {
+        throw error;
+      }
+      return normalizeWebShelfRows(snapshot, limit);
+    }
   },
 });

package/src/clis/weread/utils.ts

@@ -12,11 +12,16 @@ import type { BrowserCookie, IPage } from '../../types.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';
+const WEREAD_AUTH_ERRCODES = new Set([-2010, -2012]);
 
 function buildCookieHeader(cookies: BrowserCookie[]): string {
   return cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join('; ');
 }
 
+function isAuthErrorResponse(resp: Response, data: any): boolean {
+  return resp.status === 401 || WEREAD_AUTH_ERRCODES.has(Number(data?.errcode));
+}
+
 /**
  * Fetch a public WeRead web endpoint (Node.js direct fetch).
  * Used by search and ranking commands (browser: false).
@@ -78,7 +83,7 @@ export async function fetchPrivateApi(page: IPage, path: string, params?: Record
     throw new CliError('PARSE_ERROR', `Invalid JSON response for ${path}`, 'WeRead may have returned an HTML error page');
   }
 
-  if (resp.status === 401 || data?.errcode === -2010) {
+  if (isAuthErrorResponse(resp, data)) {
     throw new CliError('AUTH_REQUIRED', 'Not logged in to WeRead', 'Please log in to weread.qq.com in Chrome first');
   }
   if (!resp.ok) {

package/src/daemon.ts

@@ -198,6 +198,7 @@ const wss = new WebSocketServer({
 wss.on('connection', (ws: WebSocket) => {
   console.error('[daemon] Extension connected');
   extensionWs = ws;
+  extensionVersion = null; // cleared until hello message arrives
 
   // ── Heartbeat: ping every 15s, close if 2 pongs missed ──
   let missedPongs = 0;

package/src/doctor.ts

@@ -95,11 +95,15 @@ export async function runBrowserDoctor(opts: DoctorOptions = {}): Promise<Doctor
     issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
   }
 
-  if (status.extensionVersion && opts.cliVersion && status.extensionVersion !== opts.cliVersion) {
-    issues.push(
-      `Extension version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
-      '  Download the latest extension from: https://github.com/jackwener/opencli/releases',
-    );
+  if (status.extensionVersion && opts.cliVersion) {
+    const extMajor = status.extensionVersion.split('.')[0];
+    const cliMajor = opts.cliVersion.split('.')[0];
+    if (extMajor !== cliMajor) {
+      issues.push(
+        `Extension major version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+        '  Download the latest extension from: https://github.com/jackwener/opencli/releases',
+      );
+    }
   }
 
   return {

package/src/execution.ts

@@ -19,8 +19,6 @@ import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook, type HookContext } from './hooks.js';
 import { checkDaemonStatus } from './browser/discover.js';
-import { PKG_VERSION } from './version.js';
-import chalk from 'chalk';
 
 const _loadedModules = new Set<string>();
 
@@ -186,13 +184,6 @@ export async function executeCommand(
           '  Then run: opencli doctor',
         );
       }
-      // ── Version mismatch: warn but don't block ──
-      if (status.extensionVersion && status.extensionVersion !== PKG_VERSION) {
-        process.stderr.write(
-          chalk.yellow(`⚠  Extension v${status.extensionVersion} ≠ CLI v${PKG_VERSION} — consider updating the extension.\n`)
-        );
-      }
-
       ensureRequiredEnv(cmd);
       const BrowserFactory = getBrowserFactory();
       result = await browserSession(BrowserFactory, async (page) => {

package/src/extension-manifest-regression.test.ts

@@ -0,0 +1,17 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+
+describe('extension manifest regression', () => {
+  it('keeps host permissions required by chrome.cookies.getAll', async () => {
+    const manifestPath = path.resolve(process.cwd(), 'extension', 'manifest.json');
+    const raw = await fs.readFile(manifestPath, 'utf8');
+    const manifest = JSON.parse(raw) as {
+      permissions?: string[];
+      host_permissions?: string[];
+    };
+
+    expect(manifest.permissions).toContain('cookies');
+    expect(manifest.host_permissions).toContain('<all_urls>');
+  });
+});

package/src/weread-private-api-regression.test.ts

@@ -56,6 +56,24 @@ describe('weread private API regression', () => {
     await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toThrow('Not logged in');
   });
 
+  it('maps auth-expired API error codes to AUTH_REQUIRED even on HTTP 200', async () => {
+    const mockPage = {
+      getCookies: vi.fn().mockResolvedValue([]),
+      evaluate: vi.fn(),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+    }));
+
+    await expect(fetchPrivateApi(mockPage, '/book/info')).rejects.toMatchObject({
+      code: 'AUTH_REQUIRED',
+      message: 'Not logged in to WeRead',
+    });
+  });
+
   it('maps non-auth API errors to API_ERROR', async () => {
     const mockPage = {
       getCookies: vi.fn().mockResolvedValue([]),
@@ -147,4 +165,193 @@ 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 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' },
+        ]),
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockImplementation(async (source: string) => {
+        expect(source).toContain('shelf:rawBooks:vid-current');
+        expect(source).toContain('shelf:shelfIndexes:vid-current');
+        return {
+          cacheFound: true,
+          rawBooks: [
+            {
+              bookId: '40055543',
+              title: '置身事内：中国政府与经济发展',
+              author: '兰小欢',
+            },
+            {
+              bookId: '29196155',
+              title: '文明、现代化、价值投资与中国',
+              author: '李录',
+            },
+          ],
+          shelfIndexes: [
+            { bookId: '29196155', idx: 0, role: 'book' },
+            { bookId: '40055543', idx: 1, role: 'book' },
+          ],
+          lastChapters: {
+            '29196155': 40,
+            '40055543': 60,
+          },
+        };
+      }),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+    }));
+
+    const result = await command!.func!(mockPage, { limit: 1 });
+
+    expect(mockPage.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
+    expect(mockPage.evaluate).toHaveBeenCalledTimes(1);
+    expect(result).toEqual([
+      {
+        title: '文明、现代化、价值投资与中国',
+        author: '李录',
+        progress: '-',
+        bookId: '29196155',
+      },
+    ]);
+  });
+
+  it('rethrows AUTH_REQUIRED when the current session has no structured shelf cache', async () => {
+    const command = getRegistry().get('weread/shelf');
+    expect(command?.func).toBeTypeOf('function');
+
+    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' },
+        ]),
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({
+        cacheFound: false,
+        rawBooks: [],
+        shelfIndexes: [],
+        lastChapters: {},
+      }),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+    }));
+
+    await expect(command!.func!(mockPage, { limit: 20 })).rejects.toMatchObject({
+      code: 'AUTH_REQUIRED',
+      message: 'Not logged in to WeRead',
+    });
+    expect(mockPage.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
+  });
+
+  it('returns an empty list when the current session cache is confirmed but empty', async () => {
+    const command = getRegistry().get('weread/shelf');
+    expect(command?.func).toBeTypeOf('function');
+
+    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' },
+        ]),
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({
+        cacheFound: true,
+        rawBooks: [],
+        shelfIndexes: [],
+        lastChapters: {},
+      }),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+    }));
+
+    const result = await command!.func!(mockPage, { limit: 20 });
+
+    expect(mockPage.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
+    expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
+    expect(result).toEqual([]);
+  });
+
+  it('falls back to raw book cache order when shelf indexes are unavailable', async () => {
+    const command = getRegistry().get('weread/shelf');
+    expect(command?.func).toBeTypeOf('function');
+
+    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' },
+        ]),
+      goto: vi.fn().mockResolvedValue(undefined),
+      evaluate: vi.fn().mockResolvedValue({
+        cacheFound: true,
+        rawBooks: [
+          {
+            bookId: '40055543',
+            title: '置身事内：中国政府与经济发展',
+            author: '兰小欢',
+          },
+          {
+            bookId: '29196155',
+            title: '文明、现代化、价值投资与中国',
+            author: '李录',
+          },
+        ],
+        shelfIndexes: [],
+      }),
+    } as any;
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: () => Promise.resolve({ errcode: -2012, errmsg: '登录超时' }),
+    }));
+
+    const result = await command!.func!(mockPage, { limit: 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: '置身事内：中国政府与经济发展',
+        author: '兰小欢',
+        progress: '-',
+        bookId: '40055543',
+      },
+      {
+        title: '文明、现代化、价值投资与中国',
+        author: '李录',
+        progress: '-',
+        bookId: '29196155',
+      },
+    ]);
+  });
 });

package/tests/e2e/browser-public.test.ts

@@ -35,7 +35,7 @@ function isImdbChallenge(result: CliResult): boolean {
 
 function isBrowserBridgeUnavailable(result: CliResult): boolean {
   const text = `${result.stderr}\n${result.stdout}`;
-  return /Browser Bridge not connected|Extension.*not connected|not connected.*extension/i.test(text);
+  return /Browser Bridge.*not connected|Extension.*not connected/i.test(text);
 }
 
 async function expectImdbDataOrChallengeSkip(args: string[], label: string): Promise<any[] | null> {

package/tests/e2e/output-formats.test.ts

@@ -1,6 +1,7 @@
 /**
  * E2E tests for output format rendering.
- * Uses hackernews (public, fast) as a stable data source.
+ * Uses the built-in list command so renderer coverage does not depend on
+ * external network availability.
  */
 
 import { describe, it, expect } from 'vitest';
@@ -10,19 +11,22 @@ const FORMATS = ['json', 'yaml', 'csv', 'md'] as const;
 
 describe('output formats E2E', () => {
   for (const fmt of FORMATS) {
-    it(`hackernews top -f ${fmt} produces valid output`, async () => {
-      const { stdout, code } = await runCli(['hackernews', 'top', '--limit', '2', '-f', fmt]);
+    it(`list -f ${fmt} produces valid output`, async () => {
+      const { stdout, code } = await runCli(['list', '-f', fmt]);
       expect(code).toBe(0);
       expect(stdout.trim().length).toBeGreaterThan(0);
 
       if (fmt === 'json') {
         const data = parseJsonOutput(stdout);
         expect(Array.isArray(data)).toBe(true);
-        expect(data.length).toBe(2);
+        expect(data.length).toBeGreaterThan(50);
+        expect(data[0]).toHaveProperty('command');
+        expect(data[0]).toHaveProperty('site');
       }
 
       if (fmt === 'yaml') {
-        expect(stdout).toContain('title:');
+        expect(stdout).toContain('command:');
+        expect(stdout).toContain('site:');
       }
 
       if (fmt === 'csv') {
@@ -33,16 +37,8 @@ describe('output formats E2E', () => {
 
       if (fmt === 'md') {
         // Markdown table should have pipe characters
-        expect(stdout).toContain('|');
+        expect(stdout).toContain('| command |');
       }
     }, 30_000);
   }
-
-  it('list -f csv produces valid csv', async () => {
-    const { stdout, code } = await runCli(['list', '-f', 'csv']);
-    expect(code).toBe(0);
-    const lines = stdout.trim().split('\n');
-    // Header + many data lines
-    expect(lines.length).toBeGreaterThan(50);
-  });
 });

package/tests/e2e/plugin-management.test.ts

@@ -60,7 +60,10 @@ describe('plugin management E2E', () => {
     const lock = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
     expect(lock[PLUGIN_NAME]).toBeDefined();
     expect(lock[PLUGIN_NAME].commitHash).toBeTruthy();
-    expect(lock[PLUGIN_NAME].source).toContain('opencli-plugin-hot-digest');
+    expect(lock[PLUGIN_NAME].source).toMatchObject({
+      kind: 'git',
+    });
+    expect(lock[PLUGIN_NAME].source.url).toContain('opencli-plugin-hot-digest');
     expect(lock[PLUGIN_NAME].installedAt).toBeTruthy();
   }, 60_000);
 

package/tests/e2e/public-commands.test.ts

@@ -21,7 +21,7 @@ function isExpectedChineseSiteRestriction(code: number, stderr: string): boolean
 
 function isExpectedApplePodcastsRestriction(code: number, stderr: string): boolean {
   if (code === 0) return false;
-  return /Error \[FETCH_ERROR\]: (Charts API HTTP \d+|Unable to reach Apple Podcasts charts)/.test(stderr)
+  return /(?:Error \[FETCH_ERROR\]: )?(Charts API HTTP \d+|Unable to reach Apple Podcasts charts)/.test(stderr)
     || stderr === ''; // timeout killed the process before any output
 }
 
@@ -34,6 +34,17 @@ function isExpectedGoogleRestriction(code: number, stderr: string): boolean {
 // Keep old name as alias for existing tests
 const isExpectedXiaoyuzhouRestriction = isExpectedChineseSiteRestriction;
 
+describe('public command restriction detectors', () => {
+  it('treats current Apple Podcasts CliError rendering as an expected restriction', () => {
+    expect(
+      isExpectedApplePodcastsRestriction(
+        1,
+        '⚠️ Unable to reach Apple Podcasts charts for US\n→ Apple charts may be temporarily unavailable (ECONNRESET). Try again later.\n',
+      ),
+    ).toBe(true);
+  });
+});
+
 describe('public commands E2E', () => {
   // ── bloomberg (RSS-backed, browser: false) ──
   it('bloomberg main returns structured headline data', async () => {

package/vitest.config.ts

@@ -16,21 +16,7 @@ export default defineConfig({
       {
         test: {
           name: 'adapter',
-          include: [
-            'src/clis/bilibili/**/*.test.ts',
-            'src/clis/imdb/**/*.test.ts',
-            'src/clis/jd/**/*.test.ts',
-            'src/clis/linux-do/**/*.test.ts',
-            'src/clis/xiaohongshu/**/*.test.ts',
-            'src/clis/twitter/**/*.test.ts',
-            'src/clis/douban/**/*.test.ts',
-            'src/clis/zhihu/**/*.test.ts',
-            'src/clis/v2ex/**/*.test.ts',
-            'src/clis/weread/**/*.test.ts',
-            'src/clis/36kr/**/*.test.ts',
-            'src/clis/producthunt/**/*.test.ts',
-            'src/clis/paperreview/**/*.test.ts',
-          ],
+          include: ['src/clis/**/*.test.ts'],
           sequence: { groupOrder: 1 },
         },
       },