@jackwener/opencli 1.7.21 → 1.8.0

package/clis/weread-official/notes.js

@@ -0,0 +1,171 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    callGateway,
+    emptyResult,
+    formatDate,
+    makeDeepLink,
+    parseRange,
+    requireBookId,
+    requirePositiveInt,
+    truncate,
+} from './utils.js';
+
+/**
+ * Two modes share a single command (matches the ninehills reference shape):
+ *
+ *   - No bookId → `/user/notebooks` overview. One row per book that has notes.
+ *                 Total-note column follows SKILL.md statistical contract:
+ *                 `total = reviewCount + noteCount + bookmarkCount`. The
+ *                 individual fields stay separate so downstream consumers do
+ *                 not have to re-derive them.
+ *
+ *   - With bookId → merge `/book/bookmarklist` (highlights) +
+ *                    `/review/list/mine` (thoughts/reviews) into one feed.
+ *                    Bookmarks (type=0) are filtered server-side already.
+ *
+ * Pagination of `/user/notebooks` is cursor-based via `lastSort`; this command
+ * surfaces `--last-sort` rather than offset/limit to keep the SKILL.md contract
+ * visible at the CLI surface.
+ */
+cli({
+    site: 'weread-official',
+    name: 'notes',
+    access: 'read',
+    description: 'List notebooks overview or merged highlights+thoughts for a book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'bookId', positional: true, help: 'Limit to one book; omit for full notebook overview' },
+        { name: 'count', type: 'int', default: 20, help: 'Page size for the notebooks overview (1-100)' },
+        { name: 'last-sort', type: 'int', help: 'Cursor: pass previous page sort value to fetch the next page (/user/notebooks)' },
+    ],
+    columns: ['kind', 'bookId', 'title', 'author', 'chapter', 'reviewCount', 'noteCount', 'bookmarkCount', 'totalNotes', 'progress', 'finished', 'sort', 'range', 'text', 'thought', 'star', 'createTime', 'link'],
+    func: async (args) => {
+        const rawBookId = args.bookId !== undefined && args.bookId !== null && String(args.bookId).trim() !== ''
+            ? requireBookId(args.bookId)
+            : null;
+
+        if (!rawBookId) {
+            return listNotebooks(args);
+        }
+        return listBookNotes(rawBookId);
+    },
+});
+
+async function listNotebooks(args) {
+    const count = requirePositiveInt(args.count, 'count', { defaultValue: 20, max: 100 });
+    const params = { count };
+    if (args['last-sort'] !== undefined && args['last-sort'] !== null && args['last-sort'] !== '') {
+        params.lastSort = requirePositiveInt(args['last-sort'], 'last-sort');
+    }
+    const payload = await callGateway('/user/notebooks', params);
+    const books = Array.isArray(payload?.books) ? payload.books : [];
+    if (books.length === 0) {
+        emptyResult('notes', 'No notebooks found.');
+    }
+    return books.map((entry) => {
+        const book = entry?.book ?? {};
+        const bookId = String(entry?.bookId ?? book?.bookId ?? '').trim();
+        const reviewCount = Number(entry?.reviewCount ?? 0);
+        const noteCount = Number(entry?.noteCount ?? 0);
+        const bookmarkCount = Number(entry?.bookmarkCount ?? 0);
+        return {
+            kind: 'notebook',
+            bookId,
+            title: String(book?.title ?? ''),
+            author: String(book?.author ?? ''),
+            chapter: '',
+            reviewCount,
+            noteCount,
+            bookmarkCount,
+            totalNotes: reviewCount + noteCount + bookmarkCount,
+            progress: String(entry?.readingProgress ?? ''),
+            finished: Number(entry?.markedStatus ?? 0) === 1,
+            sort: Number(entry?.sort ?? 0),
+            range: '',
+            text: '',
+            thought: '',
+            star: '',
+            createTime: '',
+            link: bookId ? makeDeepLink({ bookId }) : '',
+        };
+    });
+}
+
+async function listBookNotes(bookId) {
+    const [bookmarksResp, reviewsResp] = await Promise.all([
+        callGateway('/book/bookmarklist', { bookId }),
+        callGateway('/review/list/mine', { bookid: bookId }),
+    ]);
+
+    const chapterIndex = new Map();
+    const chapterList = Array.isArray(bookmarksResp?.chapters) ? bookmarksResp.chapters : [];
+    for (const ch of chapterList) {
+        const uid = String(ch?.chapterUid ?? '').trim();
+        if (!uid) continue;
+        chapterIndex.set(uid, String(ch?.title ?? ''));
+    }
+
+    const rows = [];
+
+    const bookmarks = Array.isArray(bookmarksResp?.updated) ? bookmarksResp.updated : [];
+    for (const bm of bookmarks) {
+        const chapterUid = String(bm?.chapterUid ?? '').trim();
+        const { rangeStart, rangeEnd } = parseRange(bm?.range);
+        rows.push({
+            kind: 'highlight',
+            bookId,
+            title: '',
+            author: '',
+            chapter: chapterIndex.get(chapterUid) ?? '',
+            reviewCount: 0,
+            noteCount: 0,
+            bookmarkCount: 0,
+            totalNotes: 0,
+            progress: '',
+            finished: false,
+            sort: 0,
+            range: String(bm?.range ?? ''),
+            text: truncate(bm?.markText, 400),
+            thought: '',
+            star: '',
+            createTime: formatDate(bm?.createTime),
+            link: rangeStart && rangeEnd && chapterUid
+                ? makeDeepLink({ bookId, chapterUid, rangeStart, rangeEnd })
+                : (chapterUid ? makeDeepLink({ bookId, chapterUid }) : makeDeepLink({ bookId })),
+        });
+    }
+
+    const reviews = Array.isArray(reviewsResp?.reviews) ? reviewsResp.reviews : [];
+    for (const wrapper of reviews) {
+        const rv = wrapper?.review ?? {};
+        const chapterUid = String(rv?.chapterUid ?? '').trim();
+        const star = Number(rv?.star ?? -1);
+        rows.push({
+            kind: 'thought',
+            bookId,
+            title: '',
+            author: '',
+            chapter: String(rv?.chapterName ?? '') || (chapterIndex.get(chapterUid) ?? ''),
+            reviewCount: 0,
+            noteCount: 0,
+            bookmarkCount: 0,
+            totalNotes: 0,
+            progress: '',
+            finished: Number(rv?.isFinish ?? 0) === 1,
+            sort: 0,
+            range: String(rv?.range ?? ''),
+            text: '',
+            thought: truncate(rv?.content, 400),
+            star: star >= 0 ? String(star) : '',
+            createTime: formatDate(rv?.createTime),
+            link: chapterUid ? makeDeepLink({ bookId, chapterUid }) : makeDeepLink({ bookId }),
+        });
+    }
+
+    if (rows.length === 0) {
+        emptyResult('notes', `No highlights or thoughts saved for bookId=${bookId}.`);
+    }
+    return rows;
+}

package/clis/weread-official/readdata.js

@@ -0,0 +1,158 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+    callGateway,
+    emptyResult,
+    formatDate,
+    formatDuration,
+    requireChoice,
+    requirePositiveInt,
+} from './utils.js';
+
+/**
+ * `/readdata/detail` — reading statistics summary.
+ * Per SKILL.md every duration field is in SECONDS — `totalReadTime`,
+ * `dayAverageReadTime`, `readLongest[].readTime`, `preferTime`, etc.
+ * `preferAuthor[].readTime` is the one exception (already formatted by server
+ * as "X小时Y分钟"); we surface it verbatim.
+ *
+ * Output uses a `section` column so callers can filter:
+ *   - summary       — single overview row
+ *   - longest       — books / albums sorted by read time
+ *   - readStat      — counts (读过 / 读完 / 阅读 / 笔记)
+ *   - preferCategory / preferAuthor / preferPublisher
+ *   - preferTime    — 24h time distribution (starts at 6am per SKILL.md)
+ */
+const MODE_CHOICES = ['weekly', 'monthly', 'annually', 'overall'];
+
+cli({
+    site: 'weread-official',
+    name: 'readdata',
+    access: 'read',
+    description: 'Reading statistics: time, streak, preferences, top books',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'mode', default: 'monthly', choices: MODE_CHOICES, help: 'Stat window: weekly / monthly / annually / overall' },
+        { name: 'base-time', type: 'int', help: 'Optional Unix timestamp inside the target period; default is current period' },
+    ],
+    columns: ['section', 'idx', 'key', 'value', 'detail'],
+    func: async (args) => {
+        const mode = requireChoice(args.mode, MODE_CHOICES, 'mode', 'monthly');
+        const params = { mode };
+        if (args['base-time'] !== undefined && args['base-time'] !== null && args['base-time'] !== '') {
+            params.baseTime = requirePositiveInt(args['base-time'], 'base-time');
+        }
+        const payload = await callGateway('/readdata/detail', params);
+
+        const rows = [];
+        const totalReadTime = Number(payload?.totalReadTime ?? 0);
+        const dayAverage = Number(payload?.dayAverageReadTime ?? 0);
+        const readDays = Number(payload?.readDays ?? 0);
+        const compareRaw = payload?.compare;
+        const compare = Number.isFinite(Number(compareRaw)) ? Number(compareRaw) : null;
+
+        const summary = [
+            ['mode', mode, ''],
+            ['baseTime', formatDate(payload?.baseTime), String(payload?.baseTime ?? '')],
+            ['readDays', String(readDays), ''],
+            ['totalReadTime', formatDuration(totalReadTime), `${totalReadTime}s`],
+            ['dayAverageReadTime', formatDuration(dayAverage), `${dayAverage}s`],
+            ['compareToPrev', compare === null ? '' : `${(compare * 100).toFixed(1)}%`, ''],
+            ['readRate', payload?.readRate !== undefined ? `${Number(payload.readRate).toFixed(1)}%` : '', ''],
+            ['preferTimeWord', String(payload?.preferTimeWord ?? ''), ''],
+            ['preferCategoryWord', String(payload?.preferCategoryWord ?? ''), ''],
+        ];
+        for (let i = 0; i < summary.length; i += 1) {
+            const [key, value, detail] = summary[i];
+            rows.push({ section: 'summary', idx: i + 1, key, value, detail });
+        }
+
+        const longest = Array.isArray(payload?.readLongest) ? payload.readLongest : [];
+        longest.forEach((entry, i) => {
+            const book = entry?.book ?? {};
+            const albumInfo = entry?.albumInfo ?? null;
+            const title = albumInfo ? String(albumInfo?.name ?? '') : String(book?.title ?? '');
+            const author = albumInfo ? String(albumInfo?.authorName ?? '') : String(book?.author ?? '');
+            const tags = Array.isArray(entry?.tags) ? entry.tags.join(',') : '';
+            const readTime = Number(entry?.readTime ?? 0);
+            rows.push({
+                section: 'longest',
+                idx: i + 1,
+                key: title,
+                value: formatDuration(readTime),
+                detail: `${author}${tags ? `  [${tags}]` : ''}`,
+            });
+        });
+
+        const readStat = Array.isArray(payload?.readStat) ? payload.readStat : [];
+        readStat.forEach((entry, i) => {
+            rows.push({
+                section: 'readStat',
+                idx: i + 1,
+                key: String(entry?.stat ?? ''),
+                value: String(entry?.counts ?? ''),
+                detail: '',
+            });
+        });
+
+        const preferCategory = Array.isArray(payload?.preferCategory) ? payload.preferCategory : [];
+        preferCategory.forEach((entry, i) => {
+            const seconds = Number(entry?.readingTime ?? 0);
+            rows.push({
+                section: 'preferCategory',
+                idx: i + 1,
+                key: String(entry?.categoryTitle ?? ''),
+                value: formatDuration(seconds),
+                detail: `${Number(entry?.readingCount ?? 0)}本`,
+            });
+        });
+
+        const preferAuthor = Array.isArray(payload?.preferAuthor) ? payload.preferAuthor : [];
+        preferAuthor.forEach((entry, i) => {
+            rows.push({
+                section: 'preferAuthor',
+                idx: i + 1,
+                key: String(entry?.name ?? ''),
+                // preferAuthor[].readTime is server-formatted ("5小时30分钟"), not seconds.
+                value: String(entry?.readTime ?? ''),
+                detail: `${Number(entry?.count ?? 0)}本`,
+            });
+        });
+
+        const preferPublisher = Array.isArray(payload?.preferPublisher) ? payload.preferPublisher : [];
+        preferPublisher.forEach((entry, i) => {
+            rows.push({
+                section: 'preferPublisher',
+                idx: i + 1,
+                key: String(entry?.name ?? ''),
+                value: `${Number(entry?.count ?? 0)}本`,
+                detail: '',
+            });
+        });
+
+        const preferTime = Array.isArray(payload?.preferTime) ? payload.preferTime : [];
+        if (preferTime.length === 24) {
+            // SKILL.md: order starts at 06:00 and wraps to 05:00. Translate to a flat
+            // (hour-of-day → duration) view so consumers do not need to know the offset.
+            for (let i = 0; i < 24; i += 1) {
+                const hour = (6 + i) % 24;
+                const seconds = Number(preferTime[i] ?? 0);
+                rows.push({
+                    section: 'preferTime',
+                    idx: i + 1,
+                    key: `${String(hour).padStart(2, '0')}:00`,
+                    value: formatDuration(seconds),
+                    detail: `${seconds}s`,
+                });
+            }
+        }
+
+        if (rows.length === 0) {
+            emptyResult('readdata', `No reading data for mode=${mode}.`);
+        }
+        return rows;
+    },
+});
+
+export { MODE_CHOICES };

package/clis/weread-official/review.js

@@ -0,0 +1,93 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import {
+    callGateway,
+    emptyResult,
+    formatDate,
+    formatStar,
+    makeDeepLink,
+    requireBookId,
+    requirePositiveInt,
+    truncate,
+} from './utils.js';
+
+/**
+ * `/review/list` (public book reviews). Per SKILL.md the `reviewListType`
+ * enum is:
+ *   0=all  1=recommend  2=不行(thumbs-down)  3=newest  4=一般(neutral)
+ *
+ * Pagination is `idx`-based (use `idx` from last row of previous page as the
+ * next `maxIdx`), with an optional `synckey` carried forward. Surface these
+ * to the user instead of synthesizing an offset scheme so the SKILL contract
+ * stays visible.
+ */
+const TYPE_ALIASES = Object.freeze({
+    all: 0,
+    recommend: 1,
+    'thumbs-down': 2,
+    newest: 3,
+    neutral: 4,
+});
+
+cli({
+    site: 'weread-official',
+    name: 'review',
+    access: 'read',
+    description: 'Browse public reviews of a WeRead book',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'bookId', positional: true, required: true, help: 'WeRead bookId (from `weread-official search`)' },
+        { name: 'type', default: 'all', choices: Object.keys(TYPE_ALIASES), help: 'Review filter (all/recommend/thumbs-down/newest/neutral)' },
+        { name: 'count', type: 'int', default: 20, help: 'Page size (1-100, default 20)' },
+        { name: 'max-idx', type: 'int', default: 0, help: 'Pagination cursor — pass idx from last row of previous page' },
+        { name: 'synckey', type: 'int', help: 'Sync cursor returned by previous response' },
+    ],
+    columns: ['rank', 'idx', 'reviewId', 'star', 'starLabel', 'author', 'isFinish', 'chapter', 'content', 'createTime', 'link'],
+    func: async (args) => {
+        const bookId = requireBookId(args.bookId);
+        const typeKey = String(args.type ?? 'all').trim();
+        if (!Object.prototype.hasOwnProperty.call(TYPE_ALIASES, typeKey)) {
+            throw new ArgumentError(
+                `weread-official: type must be one of: ${Object.keys(TYPE_ALIASES).join(', ')}`,
+            );
+        }
+        const reviewListType = TYPE_ALIASES[typeKey];
+        const count = requirePositiveInt(args.count, 'count', { defaultValue: 20, max: 100 });
+        const params = { bookId, reviewListType, count, maxIdx: Number(args['max-idx'] ?? 0) };
+        if (args.synckey !== undefined && args.synckey !== null && args.synckey !== '') {
+            params.synckey = requirePositiveInt(args.synckey, 'synckey');
+        }
+
+        const payload = await callGateway('/review/list', params);
+        const reviews = Array.isArray(payload?.reviews) ? payload.reviews : [];
+        if (reviews.length === 0) {
+            emptyResult('review', `No public reviews for bookId=${bookId} (type=${typeKey}).`);
+        }
+
+        return reviews.map((wrapper, i) => {
+            const reviewOuter = wrapper?.review ?? {};
+            // `/review/list` nests the actual review under reviewOuter.review
+            const rv = reviewOuter?.review ?? {};
+            const author = rv?.author ?? {};
+            const chapter = String(rv?.chapterName ?? '').trim();
+            const reviewId = String(reviewOuter?.reviewId ?? rv?.reviewId ?? '').trim();
+            return {
+                rank: i + 1,
+                idx: Number(wrapper?.idx ?? 0),
+                reviewId,
+                star: Number(rv?.star ?? 0),
+                starLabel: formatStar(rv?.star),
+                author: String(author?.name ?? ''),
+                isFinish: Number(rv?.isFinish ?? 0) === 1,
+                chapter,
+                content: truncate(rv?.content, 300),
+                createTime: formatDate(rv?.createTime),
+                link: makeDeepLink({ bookId }),
+            };
+        });
+    },
+});
+
+export { TYPE_ALIASES };

package/clis/weread-official/search.js

@@ -0,0 +1,106 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { ArgumentError } from '@jackwener/opencli/errors';
+import {
+    callGateway,
+    emptyResult,
+    formatRating,
+    makeDeepLink,
+    requirePositiveInt,
+    requireText,
+    truncate,
+} from './utils.js';
+
+/**
+ * Search scope mapping — mirrors the official SKILL.md "scope 对应关系" table.
+ * Keys are user-facing aliases; values are the int the gateway expects.
+ */
+export const SEARCH_SCOPES = Object.freeze({
+    all: 0,
+    ebook: 10,
+    webnovel: 16,
+    audio: 14,
+    author: 6,
+    fulltext: 12,
+    booklist: 13,
+    mp: 2,
+    article: 4,
+});
+
+const SCOPE_LABEL = Object.freeze({
+    0: '全部',
+    10: '电子书',
+    16: '网文小说',
+    14: '微信听书',
+    6: '作者',
+    12: '全文',
+    13: '书单',
+    2: '公众号',
+    4: '文章',
+});
+
+cli({
+    site: 'weread-official',
+    name: 'search',
+    access: 'read',
+    description: 'Search WeRead store via the official agent gateway',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [
+        { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+        { name: 'scope', default: 'ebook', choices: Object.keys(SEARCH_SCOPES), help: 'Search type (all/ebook/webnovel/audio/author/fulltext/booklist/mp/article)' },
+        { name: 'count', type: 'int', help: 'Page size (gateway default 15 when omitted)' },
+        { name: 'max-idx', type: 'int', default: 0, help: 'Pagination offset, use searchIdx of last item from previous page' },
+    ],
+    columns: ['rank', 'scope', 'bookId', 'title', 'author', 'rating', 'readingCount', 'category', 'searchIdx', 'cover', 'intro', 'link'],
+    func: async (args) => {
+        const keyword = requireText(args.keyword, 'keyword');
+        const scopeKey = String(args.scope ?? 'ebook').trim();
+        if (!Object.prototype.hasOwnProperty.call(SEARCH_SCOPES, scopeKey)) {
+            throw new ArgumentError(
+                `weread-official: scope must be one of: ${Object.keys(SEARCH_SCOPES).join(', ')}`,
+            );
+        }
+        const scope = SEARCH_SCOPES[scopeKey];
+        const params = { keyword, scope, maxIdx: args['max-idx'] ?? 0 };
+        if (args.count !== undefined && args.count !== null && args.count !== '') {
+            params.count = requirePositiveInt(args.count, 'count', { max: 100 });
+        }
+
+        const payload = await callGateway('/store/search', params);
+        const groups = Array.isArray(payload?.results) ? payload.results : [];
+        if (groups.length === 0) {
+            emptyResult('search', `No results for "${keyword}" (scope=${scopeKey}).`);
+        }
+
+        const rows = [];
+        let rank = 0;
+        for (const group of groups) {
+            const groupScope = SCOPE_LABEL[Number(group?.scope)] ?? '';
+            const books = Array.isArray(group?.books) ? group.books : [];
+            for (const entry of books) {
+                rank += 1;
+                const info = entry?.bookInfo ?? {};
+                const bookId = String(info.bookId ?? '').trim();
+                rows.push({
+                    rank,
+                    scope: groupScope,
+                    bookId,
+                    title: String(info.title ?? ''),
+                    author: String(info.author ?? ''),
+                    rating: formatRating(entry?.newRating),
+                    readingCount: Number(entry?.readingCount ?? 0),
+                    category: String(info.category ?? ''),
+                    searchIdx: Number(entry?.searchIdx ?? 0),
+                    cover: String(info.cover ?? ''),
+                    intro: truncate(info.intro, 120),
+                    link: bookId ? makeDeepLink({ bookId }) : '',
+                });
+            }
+        }
+        if (rows.length === 0) {
+            emptyResult('search', `No books found in results for "${keyword}" (scope=${scopeKey}).`);
+        }
+        return rows;
+    },
+});

package/clis/weread-official/shelf.js

@@ -0,0 +1,97 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { callGateway, emptyResult, formatDate, makeDeepLink } from './utils.js';
+
+/**
+ * `/shelf/sync` returns three independent entry kinds:
+ *   - `books[]`   — ebooks / imported / mp-style book entries
+ *   - `albums[]`  — audiobooks / podcasts (官方 SKILL.md 强调专辑 = 有声书)
+ *   - `mp`        — opaque "文章收藏" (article bookmarks) entry; non-empty
+ *                   = 1 shelf entry but its content is NOT exposed here.
+ *
+ * Per official skill: shelf count = books.length + albums.length +
+ *                     (mp non-empty ? 1 : 0). This adapter surfaces all three
+ *                     row kinds in a `kind` column so callers can filter.
+ */
+cli({
+    site: 'weread-official',
+    name: 'shelf',
+    access: 'read',
+    description: 'Sync your WeRead shelf (books + albums + article bookmark entry) via the official gateway',
+    domain: 'weread.qq.com',
+    strategy: Strategy.PUBLIC,
+    browser: false,
+    args: [],
+    columns: ['kind', 'id', 'title', 'author', 'category', 'secret', 'isTop', 'finished', 'updateTime', 'cover', 'link'],
+    func: async () => {
+        const payload = await callGateway('/shelf/sync', {});
+        const books = Array.isArray(payload?.books) ? payload.books : [];
+        const albums = Array.isArray(payload?.albums) ? payload.albums : [];
+        // `mp` is an object (or array) marking the "文章收藏" entry. Non-empty = 1 shelf entry.
+        const mp = payload?.mp;
+        const hasMp = Boolean(
+            mp && typeof mp === 'object'
+                && (Array.isArray(mp) ? mp.length > 0 : Object.keys(mp).length > 0),
+        );
+
+        const rows = [];
+
+        for (const b of books) {
+            const bookId = String(b?.bookId ?? '').trim();
+            rows.push({
+                kind: 'book',
+                id: bookId,
+                title: String(b?.title ?? ''),
+                author: String(b?.author ?? ''),
+                category: String(b?.category ?? ''),
+                secret: Number(b?.secret ?? 0) === 1,
+                isTop: Number(b?.isTop ?? 0) === 1,
+                finished: Number(b?.finishReading ?? 0) === 1,
+                updateTime: formatDate(b?.readUpdateTime ?? b?.updateTime),
+                cover: String(b?.cover ?? ''),
+                link: bookId ? makeDeepLink({ bookId }) : '',
+            });
+        }
+
+        for (const a of albums) {
+            const info = a?.albumInfo ?? {};
+            const extra = a?.albumInfoExtra ?? {};
+            const albumId = String(info?.albumId ?? '').trim();
+            rows.push({
+                kind: 'album',
+                id: albumId,
+                title: String(info?.name ?? ''),
+                author: String(info?.authorName ?? ''),
+                category: '',
+                secret: Number(extra?.secret ?? 0) === 1,
+                isTop: Number(extra?.isTop ?? 0) === 1,
+                finished: Number(info?.finish ?? 0) === 1,
+                updateTime: formatDate(extra?.lectureReadUpdateTime ?? info?.updateTime),
+                cover: String(info?.cover ?? ''),
+                link: '',
+            });
+        }
+
+        if (hasMp) {
+            // The mp entry is an opaque directory; only the count is meaningful here.
+            // Per SKILL.md it's always private, so secret=true matches the official rule.
+            rows.push({
+                kind: 'mp',
+                id: '',
+                title: '文章收藏',
+                author: '',
+                category: '',
+                secret: true,
+                isTop: false,
+                finished: false,
+                updateTime: '',
+                cover: '',
+                link: '',
+            });
+        }
+
+        if (rows.length === 0) {
+            emptyResult('shelf', 'Your WeRead shelf is empty.');
+        }
+        return rows;
+    },
+});