@jackwener/opencli 1.7.21 → 1.8.0

package/clis/weibo/utils.js

@@ -1,10 +1,39 @@
 /**
  * Shared Weibo utilities — uid extraction.
  */
-import { AuthRequiredError } from '@jackwener/opencli/errors';
+import { AuthRequiredError, CommandExecutionError } from '@jackwener/opencli/errors';
+/**
+ * `page.evaluate` may return either the raw IIFE value or a
+ * `{ session, data }` envelope depending on the browser-bridge version.
+ * Adapter code that inspected the payload directly (e.g. `Array.isArray`,
+ * truthiness checks on uid strings) silently received the envelope wrapper
+ * instead of the inner value. This helper normalizes both shapes so callers
+ * can keep their existing checks unchanged.
+ */
+export function unwrapEvaluateResult(payload) {
+    if (payload && !Array.isArray(payload) && typeof payload === 'object' && 'session' in payload && 'data' in payload) {
+        return payload.data;
+    }
+    return payload;
+}
+export function requireArrayEvaluateResult(payload, label) {
+    if (!Array.isArray(payload)) {
+        if (payload && typeof payload === 'object' && 'error' in payload) {
+            throw new CommandExecutionError(`${label}: ${String(payload.error)}`);
+        }
+        throw new CommandExecutionError(`${label} returned malformed extraction payload`);
+    }
+    return payload;
+}
+export function requireObjectEvaluateResult(payload, label) {
+    if (!payload || Array.isArray(payload) || typeof payload !== 'object') {
+        throw new CommandExecutionError(`${label} returned malformed extraction payload`);
+    }
+    return payload;
+}
 /** Get the currently logged-in user's uid from Vue store or config API. */
 export async function getSelfUid(page) {
-    const uid = await page.evaluate(`
+    const uid = unwrapEvaluateResult(await page.evaluate(`
     (() => {
       const app = document.querySelector('#app')?.__vue_app__;
       const store = app?.config?.globalProperties?.$store;
@@ -12,18 +41,18 @@ export async function getSelfUid(page) {
       if (uid) return String(uid);
       return null;
     })()
-  `);
+  `));
     if (uid)
         return uid;
     // Fallback: config API
-    const config = await page.evaluate(`
+    const config = unwrapEvaluateResult(await page.evaluate(`
     (async () => {
       const resp = await fetch('/ajax/config/get_config', {credentials: 'include'});
       if (!resp.ok) return null;
       const data = await resp.json();
       return data.ok && data.data?.uid ? String(data.data.uid) : null;
     })()
-  `);
+  `));
     if (config)
         return config;
     throw new AuthRequiredError('weibo.com');

package/clis/weibo/utils.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { CommandExecutionError } from '@jackwener/opencli/errors';
+import { requireArrayEvaluateResult, requireObjectEvaluateResult, unwrapEvaluateResult } from './utils.js';
+
+describe('unwrapEvaluateResult (browser-bridge envelope normalization)', () => {
+    it('returns the raw array unchanged when payload is already an array', () => {
+        const arr = [{ id: '1' }, { id: '2' }];
+        expect(unwrapEvaluateResult(arr)).toBe(arr);
+    });
+    it('unwraps { session, data: [...] } envelope to the inner array', () => {
+        const arr = [{ id: '1' }];
+        const env = { session: 'site:weibo:abc', data: arr };
+        expect(unwrapEvaluateResult(env)).toBe(arr);
+    });
+    it('unwraps primitive data (e.g. uid string) from Browser Bridge envelopes', () => {
+        expect(unwrapEvaluateResult({ session: 'site:weibo:abc', data: '1234567890' })).toBe('1234567890');
+    });
+    it('unwraps null payload data so getSelfUid fallback can trigger', () => {
+        expect(unwrapEvaluateResult({ session: 'site:weibo:abc', data: null })).toBe(null);
+    });
+    it('passes non-envelope objects through unchanged (e.g. profile result)', () => {
+        const obj = { screen_name: 'alice', uid: '42' };
+        expect(unwrapEvaluateResult(obj)).toBe(obj);
+    });
+    it('handles null and undefined safely', () => {
+        expect(unwrapEvaluateResult(null)).toBe(null);
+        expect(unwrapEvaluateResult(undefined)).toBe(undefined);
+    });
+    it('keeps malformed array/object payloads as typed command failures after unwrap', () => {
+        expect(requireArrayEvaluateResult([{ id: '1' }], 'weibo feed')).toEqual([{ id: '1' }]);
+        expect(() => requireArrayEvaluateResult({ error: 'API error' }, 'weibo feed')).toThrow(CommandExecutionError);
+        expect(() => requireArrayEvaluateResult({ error: 'API error' }, 'weibo feed')).toThrow('weibo feed: API error');
+        expect(requireObjectEvaluateResult({ uid: '42' }, 'weibo me')).toEqual({ uid: '42' });
+        expect(() => requireObjectEvaluateResult([{ uid: '42' }], 'weibo me')).toThrow(CommandExecutionError);
+    });
+});

package/clis/weread/search-regression.test.js

@@ -1,5 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { getRegistry } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import './search.js';
 describe('weread/search regression', () => {
     beforeEach(() => {
@@ -146,7 +147,7 @@ describe('weread/search regression', () => {
             },
         ]);
     });
-    it('falls back to empty urls when the search html request fails', async () => {
+    it('surfaces search html request failures instead of emitting empty urls', async () => {
         const command = getRegistry().get('weread/search');
         expect(command?.func).toBeTypeOf('function');
         const fetchMock = vi.fn()
@@ -166,16 +167,22 @@ describe('weread/search regression', () => {
         })
             .mockRejectedValueOnce(new Error('network timeout'));
         vi.stubGlobal('fetch', fetchMock);
-        const result = await command.func({ query: 'deep work', limit: 5 });
-        expect(result).toEqual([
-            {
-                rank: 1,
-                title: 'Deep Work',
-                author: 'Cal Newport',
-                bookId: 'abc123',
-                url: '',
-            },
-        ]);
+        await expect(command.func({ query: 'deep work', limit: 5 })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+    it('throws EmptyResultError when the public search API returns no books', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({ books: [] }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve('<html></html>'),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        await expect(command.func({ query: 'definitely-missing-book', limit: 5 })).rejects.toBeInstanceOf(EmptyResultError);
     });
     it('binds reader urls with title and author instead of title alone', async () => {
         const command = getRegistry().get('weread/search');

package/clis/weread/search.js

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '@jackwener/opencli/registry';
+import { CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
 import { fetchWebApi, WEREAD_UA, WEREAD_WEB_ORIGIN } from './utils.js';
 function decodeHtmlText(value) {
     return value
@@ -84,18 +85,19 @@ function resolveSearchResultUrl(params) {
 async function loadSearchHtmlEntries(query) {
     const url = new URL('/web/search/books', WEREAD_WEB_ORIGIN);
     url.searchParams.set('keyword', query);
-    let html = '';
+    let resp;
     try {
-        const resp = await fetch(url.toString(), {
+        resp = await fetch(url.toString(), {
             headers: { 'User-Agent': WEREAD_UA },
         });
-        if (!resp.ok)
-            return [];
-        html = await resp.text();
     }
-    catch {
-        return [];
+    catch (error) {
+        throw new CommandExecutionError(`Failed to fetch WeRead search page: ${error instanceof Error ? error.message : String(error)}`);
     }
+    if (!resp.ok) {
+        throw new CommandExecutionError(`WeRead search page request failed: HTTP ${resp.status}`);
+    }
+    const html = await resp.text();
     const items = Array.from(html.matchAll(/<li[^>]*class="wr_bookList_item"[^>]*>([\s\S]*?)<\/li>/g));
     return items.map((match) => {
         const chunk = match[1];
@@ -131,6 +133,12 @@ cli({
             loadSearchHtmlEntries(String(args.query ?? '')),
         ]);
         const books = data?.books ?? [];
+        if (!Array.isArray(books)) {
+            throw new CommandExecutionError('WeRead search API returned an unreadable books payload');
+        }
+        if (books.length === 0) {
+            throw new EmptyResultError('weread search', `No books were returned for query ${args.query}.`);
+        }
         const { exactQueues, titleOnlyQueues } = buildSearchUrlQueues(htmlEntries);
         const apiIdentityCounts = countSearchIdentities(books.map((item) => ({
             title: item.bookInfo?.title ?? '',

package/clis/weread-official/book.js

@@ -0,0 +1,135 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    callGateway,
+    emptyResult,
+    formatDate,
+    formatDuration,
+    formatRating,
+    makeDeepLink,
+    requireBookId,
+    truncate,
+} from './utils.js';
+
+/**
+ * 3-in-1 book lookup: `/book/info` always runs; `/book/chapterinfo` and
+ * `/book/getprogress` are opt-out via `--no-chapters` / `--no-progress`
+ * so users can shave 1-2 gateway calls when only a single section is needed.
+ *
+ * Output is a flat row list with a `section` column so table/json/yaml
+ * consumers can filter without ad-hoc joins:
+ *   - section=info       — single row, basic metadata
+ *   - section=chapter    — one row per chapter (level/title/wordCount)
+ *   - section=progress   — single row, progress % + cumulative read time
+ */
+cli({
+    site: 'weread-official',
+    name: 'book',
+    access: 'read',
+    description: 'Show WeRead book metadata, chapters, and reading progress',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'bookId', positional: true, required: true, help: 'WeRead bookId (from `weread-official search`)' },
+        { name: 'no-chapters', type: 'boolean', default: false, help: 'Skip /book/chapterinfo call' },
+        { name: 'no-progress', type: 'boolean', default: false, help: 'Skip /book/getprogress call' },
+    ],
+    columns: ['section', 'idx', 'key', 'value', 'link'],
+    func: async (args) => {
+        const bookId = requireBookId(args.bookId);
+
+        const tasks = [callGateway('/book/info', { bookId })];
+        const want = {
+            chapters: !args['no-chapters'],
+            progress: !args['no-progress'],
+        };
+        if (want.chapters) tasks.push(callGateway('/book/chapterinfo', { bookId }));
+        if (want.progress) tasks.push(callGateway('/book/getprogress', { bookId }));
+
+        const results = await Promise.all(tasks);
+        let cursor = 0;
+        const info = results[cursor++];
+        const chapters = want.chapters ? results[cursor++] : null;
+        const progress = want.progress ? results[cursor++] : null;
+
+        const rows = [];
+
+        // ── info section ────────────────────────────────────────────────────
+        const infoPairs = [
+            ['bookId', String(info?.bookId ?? bookId)],
+            ['title', String(info?.title ?? '')],
+            ['author', String(info?.author ?? '')],
+            ['translator', String(info?.translator ?? '')],
+            ['category', String(info?.category ?? '')],
+            ['publisher', String(info?.publisher ?? '')],
+            ['publishTime', String(info?.publishTime ?? '')],
+            ['isbn', String(info?.isbn ?? '')],
+            ['wordCount', String(info?.wordCount ?? '')],
+            ['rating', formatRating(info?.newRating)],
+            ['ratingCount', String(info?.newRatingCount ?? '')],
+            ['intro', truncate(info?.intro, 400)],
+            ['cover', String(info?.cover ?? '')],
+        ];
+        for (let i = 0; i < infoPairs.length; i += 1) {
+            const [key, value] = infoPairs[i];
+            rows.push({ section: 'info', idx: i + 1, key, value, link: '' });
+        }
+        rows.push({
+            section: 'info',
+            idx: infoPairs.length + 1,
+            key: 'link',
+            value: '',
+            link: makeDeepLink({ bookId }),
+        });
+
+        // ── chapters section ────────────────────────────────────────────────
+        if (chapters) {
+            const list = Array.isArray(chapters?.chapters) ? chapters.chapters : [];
+            list.forEach((ch, i) => {
+                const chapterUid = String(ch?.chapterUid ?? '').trim();
+                const level = Number(ch?.level ?? 1);
+                const indent = '  '.repeat(Math.max(0, level - 1));
+                const title = `${indent}${String(ch?.title ?? '')}`;
+                const wordCount = Number(ch?.wordCount ?? 0);
+                const paid = Number(ch?.paid ?? 0) === 1;
+                const price = Number(ch?.price ?? 0);
+                const meta = [`${wordCount}字`];
+                if (price > 0) meta.push(paid ? '已购买' : `${price}元`);
+                rows.push({
+                    section: 'chapter',
+                    idx: Number(ch?.chapterIdx ?? i + 1),
+                    key: chapterUid,
+                    value: `${title}  (${meta.join(' · ')})`,
+                    link: chapterUid ? makeDeepLink({ bookId, chapterUid }) : '',
+                });
+            });
+        }
+
+        // ── progress section ────────────────────────────────────────────────
+        if (progress) {
+            const p = progress?.book ?? {};
+            const pct = Number(p?.progress ?? 0);
+            const updateTime = formatDate(p?.updateTime);
+            const finishTime = pct === 100 ? formatDate(p?.finishTime) : '';
+            const cumulative = formatDuration(p?.recordReadingTime);
+            const isStart = Number(p?.isStartReading ?? 0) === 1;
+            const progressPairs = [
+                ['progress', `${pct}%`],
+                ['cumulative', cumulative],
+                ['lastReadAt', updateTime],
+                ['finishedAt', finishTime],
+                ['isStartReading', isStart ? 'true' : 'false'],
+                ['currentChapterUid', String(p?.chapterUid ?? '')],
+            ];
+            for (let i = 0; i < progressPairs.length; i += 1) {
+                const [key, value] = progressPairs[i];
+                rows.push({ section: 'progress', idx: i + 1, key, value, link: '' });
+            }
+        }
+
+        if (rows.length === 0) {
+            emptyResult('book', `No data returned for bookId=${bookId}`);
+        }
+        return rows;
+    },
+});