publishport-opencli 1.8.4-pp.1

package/clis/tieba/posts.js

@@ -0,0 +1,86 @@
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { buildTiebaPostCardsFromPagePc, buildTiebaPostItems, normalizeTiebaLimit, signTiebaPcParams, } from './utils.js';
+function getForumPageNumber(kwargs) {
+    return Math.max(1, Number(kwargs.page || 1));
+}
+function getForumUrl(kwargs) {
+    const forum = String(kwargs.forum || '');
+    return `https://tieba.baidu.com/f?kw=${encodeURIComponent(forum)}&ie=utf-8&pn=${(getForumPageNumber(kwargs) - 1) * 50}`;
+}
+/**
+ * Rebuild the signed page_pc request instead of scraping only the visible thread cards.
+ */
+function buildTiebaPagePcParams(kwargs, limit) {
+    return {
+        kw: encodeURIComponent(String(kwargs.forum || '')),
+        pn: String(getForumPageNumber(kwargs)),
+        sort_type: '-1',
+        is_newfrs: '1',
+        is_newfeed: '1',
+        rn: '30',
+        rn_need: String(Math.min(Math.max(limit + 10, 10), 30)),
+        tbs: '',
+        subapp_type: 'pc',
+        _client_type: '20',
+    };
+}
+/**
+ * Tieba expects the signed forum-list request to be replayed with the browser's cookies.
+ */
+async function fetchTiebaPagePc(page, kwargs, limit) {
+    await page.goto(getForumUrl(kwargs), { waitUntil: 'none' });
+    await page.wait(2);
+    const params = buildTiebaPagePcParams(kwargs, limit);
+    const cookies = await page.getCookies({ domain: 'tieba.baidu.com' });
+    const cookieHeader = cookies.map((item) => `${item.name}=${item.value}`).join('; ');
+    const body = new URLSearchParams({
+        ...params,
+        sign: signTiebaPcParams(params),
+    }).toString();
+    const response = await fetch('https://tieba.baidu.com/c/f/frs/page_pc', {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
+            cookie: cookieHeader,
+            'x-requested-with': 'XMLHttpRequest',
+            referer: getForumUrl(kwargs),
+            'user-agent': 'Mozilla/5.0',
+        },
+        body,
+    });
+    const text = await response.text();
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return {};
+    }
+}
+cli({
+    site: 'tieba',
+    name: 'posts',
+    access: 'read',
+    description: 'Browse posts in a tieba forum',
+    domain: 'tieba.baidu.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'forum', positional: true, required: true, type: 'string', help: 'Forum name in Chinese' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
+    ],
+    columns: ['rank', 'title', 'author', 'replies'],
+    func: async (page, kwargs) => {
+        const limit = normalizeTiebaLimit(kwargs.limit);
+        const payload = await fetchTiebaPagePc(page, kwargs, limit);
+        const rawFeeds = Array.isArray(payload.page_data?.feed_list) ? payload.page_data.feed_list : [];
+        const rawCards = buildTiebaPostCardsFromPagePc(rawFeeds);
+        const items = buildTiebaPostItems(rawCards, limit);
+        if (!items.length || payload.error_code) {
+            throw new EmptyResultError('tieba posts', 'Tieba may have blocked the forum page, or the DOM structure may have changed');
+        }
+        return items;
+    },
+});

package/clis/tieba/read.js

@@ -0,0 +1,141 @@
+import { EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { buildTiebaReadItems } from './utils.js';
+function getThreadUrl(kwargs) {
+    const threadId = String(kwargs.id || '');
+    const pageNumber = Math.max(1, Number(kwargs.page || 1));
+    return `https://tieba.baidu.com/p/${encodeURIComponent(threadId)}?pn=${pageNumber}`;
+}
+/**
+ * Ensure the browser actually landed on the requested thread page before we trust the DOM.
+ */
+function assertTiebaReadTargetPage(raw, kwargs) {
+    const expectedThreadId = String(kwargs.id || '').trim();
+    const expectedPageNumber = Math.max(1, Number(kwargs.page || 1));
+    const pathname = String(raw.pageMeta?.pathname || '').trim();
+    const actualThreadId = pathname.match(/^\/p\/(\d+)/)?.[1] || '';
+    const actualPn = String(raw.pageMeta?.pn || '').trim();
+    if (!actualThreadId || actualThreadId !== expectedThreadId) {
+        throw new EmptyResultError('tieba read', 'Tieba did not land on the requested thread page');
+    }
+    if (expectedPageNumber > 1 && actualPn !== String(expectedPageNumber)) {
+        throw new EmptyResultError('tieba read', 'Tieba did not land on the requested page');
+    }
+}
+function buildExtractReadEvaluate() {
+    return `
+    (async () => {
+      const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const waitFor = async (predicate, timeoutMs = 4000) => {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+          if (predicate()) return true;
+          await wait(100);
+        }
+        return false;
+      };
+      const normalizeText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const getVueProps = (element) => {
+        const vue = element && element.__vue__ ? element.__vue__ : null;
+        return vue ? (vue._props || vue.$props || {}) : {};
+      };
+      const extractStructuredText = (content) => {
+        if (!Array.isArray(content)) return '';
+        return content
+          .map((part) => (part && typeof part === 'object' && typeof part.text === 'string') ? part.text : '')
+          .join('')
+          .replace(/\\s+/g, ' ')
+          .trim();
+      };
+      const parseFloor = (text) => {
+        const match = (text || '').match(/第(\\d+)楼/);
+        return match ? parseInt(match[1], 10) : 0;
+      };
+
+      await waitFor(() => {
+        const hasMainTree = document.querySelector('.pb-title-wrap.pc-pb-title') || document.querySelector('.pb-content-wrap');
+        return Boolean(hasMainTree || document.querySelector('.pb-comment-item'));
+      });
+
+      const titleNode = document.querySelector('.pb-title-wrap.pc-pb-title');
+      const titleProps = getVueProps(titleNode);
+      const mainUser = document.querySelector('.head-line.user-info:not(.no-extra-margin)');
+      const mainUserProps = getVueProps(mainUser);
+      const contentWrap = document.querySelector('.pb-content-wrap');
+      const contentProps = getVueProps(contentWrap);
+      const structuredContent = Array.isArray(contentProps.content) ? contentProps.content : [];
+      const visibleContent = normalizeText(
+        contentWrap?.querySelector('.pb-content-item .text')?.textContent
+        || contentWrap?.querySelector('.text')?.textContent
+        || contentWrap?.textContent
+      );
+
+      return {
+        pageMeta: {
+          pathname: window.location.pathname || '',
+          pn: new URLSearchParams(window.location.search).get('pn') || '',
+        },
+        mainPost: {
+          title: typeof titleProps.title === 'string' && titleProps.title.trim()
+            ? titleProps.title.trim()
+            : normalizeText(titleNode?.textContent).replace(/-百度贴吧$/, '').trim(),
+          author: normalizeText(
+            mainUser?.querySelector('.head-name')?.textContent
+            || mainUser?.querySelector('.name-info .head-name')?.textContent
+            || ''
+          ),
+          fallbackAuthor: mainUserProps?.userShowInfo?.[0]?.text?.text || '',
+          contentText: visibleContent,
+          structuredText: extractStructuredText(structuredContent),
+          visibleTime: (() => {
+            const userText = normalizeText(mainUser?.textContent);
+            const match = userText.match(/(刚刚|昨天|前天|\\d+\\s*(?:分钟|小时|天)前|\\d{2}-\\d{2}(?:\\s+\\d{2}:\\d{2})?|\\d{4}-\\d{2}-\\d{2}(?:\\s+\\d{2}:\\d{2})?)/);
+            return match ? match[1].trim() : '';
+          })(),
+          structuredTime: mainUserProps?.descInfo?.time || 0,
+          hasMedia: structuredContent.length > 0 && !extractStructuredText(structuredContent),
+        },
+        replies: Array.from(document.querySelectorAll('.pb-comment-item')).map((item) => {
+          const meta = item.querySelector('.comment-desc-left')?.textContent?.replace(/\\s+/g, ' ').trim() || '';
+          return {
+            floor: parseFloor(meta),
+            author: item.querySelector('.head-name')?.textContent?.trim() || '',
+            content: item.querySelector('.comment-content .pb-content-item .text')?.textContent?.replace(/\\s+/g, ' ').trim() || '',
+            time: meta,
+          };
+        }),
+      };
+    })()
+  `;
+}
+cli({
+    site: 'tieba',
+    name: 'read',
+    access: 'read',
+    description: 'Read a tieba thread',
+    domain: 'tieba.baidu.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'id', positional: true, required: true, type: 'string', help: 'Thread ID' },
+        { name: 'page', type: 'int', default: 1, help: 'Page number' },
+        { name: 'limit', type: 'int', default: 30, help: 'Number of replies to return' },
+    ],
+    columns: ['floor', 'author', 'content', 'time'],
+    func: async (page, kwargs) => {
+        const pageNumber = Math.max(1, Number(kwargs.page || 1));
+        // Use the browser's normal settle path so we do not scrape stale DOM from the previous tab state.
+        await page.goto(getThreadUrl(kwargs));
+        const raw = (await page.evaluate(buildExtractReadEvaluate()) || {});
+        assertTiebaReadTargetPage(raw, kwargs);
+        const items = buildTiebaReadItems(raw, {
+            limit: kwargs.limit,
+            includeMainPost: pageNumber === 1,
+        });
+        if (!items.length) {
+            throw new EmptyResultError('tieba read', 'Tieba may have blocked the thread page, or the DOM structure may have changed');
+        }
+        return items;
+    },
+});

package/clis/tieba/search.js

@@ -0,0 +1,109 @@
+import { ArgumentError, EmptyResultError } from '@jackwener/opencli/errors';
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { buildTiebaSearchItems, normalizeTiebaLimit } from './utils.js';
+const MAX_SUPPORTED_PAGE = '1';
+/**
+ * Extract search result cards from tieba's current desktop search page.
+ */
+function buildExtractSearchResultsEvaluate(limit) {
+    return `
+    (async () => {
+      const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+      const waitFor = async (predicate, timeoutMs = 5000) => {
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+          if (predicate()) return true;
+          await wait(100);
+        }
+        return false;
+      };
+      const getVueProps = (element) => {
+        const vue = element && element.__vue__ ? element.__vue__ : null;
+        return vue ? (vue._props || vue.$props || {}) : {};
+      };
+      await waitFor(() => {
+        const bodyText = document.body?.innerText || '';
+        return Boolean(
+          document.querySelector('.threadcardclass.thread-new3.index-feed-cards')
+          || document.querySelector('.search-no-result, .search-nodata, .no-result')
+          || /百度安全验证|安全验证|请完成验证/.test(bodyText)
+        );
+      });
+      const items = document.querySelectorAll('.threadcardclass.thread-new3.index-feed-cards');
+      return Array.from(items).slice(0, ${limit}).map((item) => {
+        const forum = item.querySelector('.forum-name-text, .forum-name')?.textContent?.trim() || '';
+        const meta = item.querySelector('.user-forum-info')?.textContent?.replace(/\\s+/g, ' ').trim() || '';
+        const metaWithoutForum = forum && meta.startsWith(forum)
+          ? meta.slice(forum.length).trim()
+          : meta;
+        const metaMatch = metaWithoutForum.match(/^(.*?)\\s*发布于\\s*(.+)$/);
+        const actionBar = item.querySelector('.action-bar-container.search-action-bar');
+        const businessInfo = getVueProps(actionBar).businessInfo || {};
+        const href = item.querySelector('a[href*="/p/"]')?.href || '';
+        const threadId = String(businessInfo.thread_id || '').trim();
+        const title = item.querySelector('.title-wrap')?.textContent?.trim()
+          || item.querySelector('.title-content-wrap')?.textContent?.trim()
+          || '';
+        const snippet = item.querySelector('.title-content-wrap')?.textContent?.trim()
+          || item.querySelector('.abstract-wrap')?.textContent?.trim()
+          || '';
+
+        return {
+          title,
+          forum,
+          author: metaMatch ? metaMatch[1].trim() : metaWithoutForum,
+          time: metaMatch ? metaMatch[2].trim() : '',
+          snippet: snippet.substring(0, 200),
+          id: threadId,
+          url: href || (threadId ? 'https://tieba.baidu.com/p/' + threadId : ''),
+        };
+      }).filter((item) => item.title);
+    })()
+  `;
+}
+/**
+ * Normalize CLI args into the concrete search page URL.
+ */
+function getSearchUrl(kwargs) {
+    const keyword = String(kwargs.keyword || '');
+    const pageNumber = Number(kwargs.page || 1);
+    return `https://tieba.baidu.com/f/search/res?qw=${encodeURIComponent(keyword)}&ie=utf-8&pn=${pageNumber}`;
+}
+/**
+ * Tieba's current desktop search UI no longer exposes a reliable browser-page transition.
+ */
+function assertSupportedPage(kwargs) {
+    const pageNumber = String(kwargs.page || 1);
+    if (pageNumber === MAX_SUPPORTED_PAGE)
+        return;
+    throw new ArgumentError(`tieba search currently only supports --page ${MAX_SUPPORTED_PAGE}`, `Baidu Tieba search no longer exposes stable browser pagination; omit --page or use --page ${MAX_SUPPORTED_PAGE}`);
+}
+cli({
+    site: 'tieba',
+    name: 'search',
+    access: 'read',
+    description: 'Search posts across tieba',
+    domain: 'tieba.baidu.com',
+    strategy: Strategy.COOKIE,
+    browser: true,
+    navigateBefore: false,
+    args: [
+        { name: 'keyword', positional: true, required: true, type: 'string', help: 'Search keyword' },
+        // Restrict unsupported pages before the browser session starts.
+        { name: 'page', type: 'int', default: 1, choices: ['1'], help: 'Page number (currently only 1 is supported)' },
+        { name: 'limit', type: 'int', default: 20, help: 'Number of items to return' },
+    ],
+    columns: ['rank', 'id', 'title', 'forum', 'author', 'time', 'url'],
+    func: async (page, kwargs) => {
+        assertSupportedPage(kwargs);
+        const limit = normalizeTiebaLimit(kwargs.limit);
+        // Use the default browser settle path so we do not read a stale page.
+        await page.goto(getSearchUrl(kwargs));
+        const raw = await page.evaluate(buildExtractSearchResultsEvaluate(limit));
+        const items = buildTiebaSearchItems(Array.isArray(raw) ? raw : [], limit);
+        if (!items.length) {
+            throw new EmptyResultError('tieba search', 'Tieba may have blocked the result page, or the DOM structure may have changed');
+        }
+        return items;
+    },
+});

package/clis/tieba/utils.js

@@ -0,0 +1,240 @@
+import { createHash } from 'node:crypto';
+/**
+ * Shared Tieba parsing helpers used by the browser adapters.
+ */
+export const MAX_TIEBA_LIMIT = 20;
+const TIEBA_PC_SIGN_SALT = '36770b1f34c9bbf2e7d1a99d2b82fa9e';
+const TIEBA_TIME_ZONE = 'Asia/Shanghai';
+/**
+ * Keep the public CLI limit contract aligned with the real implementation.
+ */
+export function normalizeTiebaLimit(value, fallback = MAX_TIEBA_LIMIT) {
+    const parsed = Number(value ?? fallback);
+    if (!Number.isFinite(parsed) || parsed < 1)
+        return fallback;
+    return Math.min(Math.trunc(parsed), MAX_TIEBA_LIMIT);
+}
+export function normalizeText(value) {
+    return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+/**
+ * Match Tieba PC's signed request contract so forum list fetching stays stable.
+ */
+export function signTiebaPcParams(params) {
+    const payload = Object.keys(params)
+        .sort((left, right) => left.localeCompare(right))
+        .map((key) => `${key}=${params[key]}`)
+        .join('') + TIEBA_PC_SIGN_SALT;
+    return createHash('md5').update(payload).digest('hex');
+}
+export function parseTiebaCount(text) {
+    const value = normalizeText(text).toUpperCase();
+    if (!value)
+        return 0;
+    const compact = value.replace(/[^\d.W万]/g, '');
+    if (compact.endsWith('万')) {
+        return Math.round(parseFloat(compact.slice(0, -1)) * 10000);
+    }
+    if (compact.endsWith('W')) {
+        return Math.round(parseFloat(compact.slice(0, -1)) * 10000);
+    }
+    return parseInt(compact.replace(/[^\d]/g, ''), 10) || 0;
+}
+export function parseTiebaLastReply(text) {
+    const normalized = normalizeText(text).replace(/^回复于/, '').trim();
+    const match = normalized.match(/(刚刚|\d+\s*(?:分钟|小时|天)前|\d{2}-\d{2}(?:\s+\d{2}:\d{2})?|\d{4}-\d{2}-\d{2}(?:\s+\d{2}:\d{2})?)/);
+    return match ? match[1].trim() : normalized;
+}
+function buildTiebaThreadUrl(id, rawUrl) {
+    const explicitUrl = normalizeText(rawUrl);
+    if (explicitUrl)
+        return explicitUrl;
+    return id ? `https://tieba.baidu.com/p/${id}` : '';
+}
+function resolveTiebaThreadId(raw) {
+    const direct = normalizeText(raw.threadId);
+    if (direct)
+        return direct;
+    const fromUrl = normalizeText(raw.url).match(/\/p\/(\d+)/);
+    return fromUrl ? fromUrl[1] : '';
+}
+function getTiebaFeedComponent(feed, name) {
+    const components = Array.isArray(feed?.components) ? feed.components : [];
+    const match = components.find((entry) => normalizeText(entry.component) === name);
+    if (!match)
+        return {};
+    const payload = match[name];
+    return payload && typeof payload === 'object' ? payload : {};
+}
+function extractTiebaFeedAuthor(feed) {
+    const head = getTiebaFeedComponent(feed, 'feed_head');
+    const mainData = Array.isArray(head.main_data) ? head.main_data : [];
+    for (const item of mainData) {
+        const textRecord = item.text;
+        const author = normalizeText(textRecord?.text);
+        if (author)
+            return author;
+    }
+    return '';
+}
+function extractTiebaFeedTitle(feed) {
+    const title = getTiebaFeedComponent(feed, 'feed_title');
+    const titleData = Array.isArray(title.data) ? title.data : [];
+    const firstTitle = titleData[0];
+    const textInfo = firstTitle?.text_info;
+    return normalizeText(textInfo?.text) || normalizeText(feed?.business_info_map?.title);
+}
+function extractTiebaFeedCommentCount(feed) {
+    const social = getTiebaFeedComponent(feed, 'feed_social');
+    const commentCount = Number(social.comment_num ?? feed?.business_info_map?.comment_num ?? 0);
+    return Number.isFinite(commentCount) ? commentCount : 0;
+}
+function extractTiebaFeedThreadId(feed) {
+    const direct = normalizeText(feed?.business_info_map?.thread_id);
+    if (direct)
+        return direct;
+    const logParams = Array.isArray(feed?.log_param) ? feed.log_param : [];
+    const fromLog = normalizeText(logParams.find((item) => normalizeText(item?.key) === 'tid')?.value);
+    if (fromLog)
+        return fromLog;
+    const fromSchema = normalizeText(feed?.schema).match(/[?&]tid=(\d+)/);
+    return fromSchema ? fromSchema[1] : '';
+}
+function extractTiebaFeedLastReply(feed) {
+    const head = getTiebaFeedComponent(feed, 'feed_head');
+    const extraData = Array.isArray(head.extra_data) ? head.extra_data : [];
+    const first = extraData[0];
+    const prefix = normalizeText(first?.business_info_map?.time_prefix);
+    const textRecord = first?.text;
+    const rawTime = normalizeText(textRecord?.text);
+    const formattedTime = /^\d+$/.test(rawTime) ? formatTiebaUnixTime(rawTime) : rawTime;
+    return [prefix, formattedTime].filter(Boolean).join('');
+}
+/**
+ * Convert Tieba's signed `page_pc` feed entries into the stable card shape used by the CLI.
+ */
+export function buildTiebaPostCardsFromPagePc(rawFeeds) {
+    return rawFeeds
+        .filter((entry) => normalizeText(entry.layout) === 'feed' && entry.feed)
+        .map((entry) => {
+        const feed = entry.feed;
+        const threadId = extractTiebaFeedThreadId(feed);
+        return {
+            title: extractTiebaFeedTitle(feed),
+            author: extractTiebaFeedAuthor(feed),
+            descInfo: extractTiebaFeedLastReply(feed),
+            commentCount: extractTiebaFeedCommentCount(feed),
+            actionTexts: [],
+            threadId,
+            url: buildTiebaThreadUrl(threadId),
+        };
+    })
+        .filter((entry) => normalizeText(entry.title));
+}
+export function buildTiebaPostItems(rawCards, requestedLimit) {
+    const limit = normalizeTiebaLimit(requestedLimit);
+    return rawCards
+        .map((raw) => {
+        const title = normalizeText(raw.title);
+        const id = resolveTiebaThreadId(raw);
+        const actionTexts = Array.isArray(raw.actionTexts) ? raw.actionTexts.map(normalizeText).filter(Boolean) : [];
+        const commentText = actionTexts.find((text) => /评论/.test(text)) || actionTexts[actionTexts.length - 1] || '';
+        return {
+            title,
+            author: normalizeText(raw.author),
+            replies: Number.isFinite(Number(raw.commentCount))
+                ? Number(raw.commentCount)
+                : parseTiebaCount(commentText),
+            last_reply: parseTiebaLastReply(String(raw.descInfo ?? '')),
+            id,
+            url: buildTiebaThreadUrl(id, raw.url),
+        };
+    })
+        .filter((item) => item.title)
+        .slice(0, limit)
+        .map((item, index) => ({ rank: index + 1, ...item }));
+}
+export function buildTiebaSearchItems(rawItems, requestedLimit) {
+    const limit = normalizeTiebaLimit(requestedLimit);
+    return rawItems
+        .map((raw) => {
+        const url = normalizeText(raw.url);
+        const directId = normalizeText(raw.id);
+        const idFromUrl = url.match(/\/p\/(\d+)/)?.[1] || '';
+        return {
+            title: normalizeText(raw.title),
+            forum: normalizeText(raw.forum),
+            author: normalizeText(raw.author),
+            time: normalizeText(raw.time),
+            snippet: normalizeText(raw.snippet).slice(0, 200),
+            id: directId || idFromUrl,
+            url,
+        };
+    })
+        .filter((item) => item.title)
+        .slice(0, limit)
+        .map((item, index) => ({ rank: index + 1, ...item }));
+}
+function formatTiebaUnixTime(value) {
+    const ts = Number(value || 0);
+    if (!Number.isFinite(ts) || ts <= 0)
+        return '';
+    const parts = new Intl.DateTimeFormat('sv-SE', {
+        timeZone: TIEBA_TIME_ZONE,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).formatToParts(new Date(ts * 1000));
+    const values = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+    return `${values.year}-${values.month}-${values.day} ${values.hour}:${values.minute}`;
+}
+function parseTiebaReplyTime(text) {
+    const normalized = normalizeText(text);
+    const withoutFloor = normalized.replace(/^第\d+楼\s+/, '').trim();
+    const match = withoutFloor.match(/^(刚刚|昨天|前天|\d+\s*(?:分钟|小时|天)前|\d{2}-\d{2}(?:\s+\d{2}:\d{2})?|\d{4}-\d{2}-\d{2}(?:\s+\d{2}:\d{2})?)/);
+    return match ? match[1].trim() : withoutFloor;
+}
+function buildMainPostItem(mainPost) {
+    if (!mainPost)
+        return null;
+    const title = normalizeText(mainPost.title);
+    const author = normalizeText(mainPost.author) || normalizeText(mainPost.fallbackAuthor);
+    const body = normalizeText(mainPost.contentText) || normalizeText(mainPost.structuredText);
+    const hasMedia = Boolean(mainPost.hasMedia);
+    const content = [title, body || (hasMedia ? '[media]' : '')].filter(Boolean).join(' ').trim();
+    if (!content)
+        return null;
+    return {
+        floor: 1,
+        author,
+        content,
+        time: normalizeText(mainPost.visibleTime) || formatTiebaUnixTime(mainPost.structuredTime),
+    };
+}
+export function buildTiebaReadItems(payload, options = {}) {
+    const fallback = Number.isFinite(Number(options.limit)) ? Number(options.limit) : 30;
+    const limit = Math.max(1, Math.trunc(fallback));
+    const includeMainPost = options.includeMainPost !== false;
+    const items = [];
+    const mainPost = buildMainPostItem(payload.mainPost);
+    if (includeMainPost && mainPost)
+        items.push(mainPost);
+    const replies = Array.isArray(payload.replies) ? payload.replies : [];
+    const replyItems = [];
+    for (const reply of replies) {
+        const floor = Number(reply.floor || 0);
+        const content = normalizeText(reply.content);
+        if (!Number.isFinite(floor) || floor < 1 || !content)
+            continue;
+        replyItems.push({
+            floor,
+            author: normalizeText(reply.author),
+            content,
+            time: parseTiebaReplyTime(String(reply.time ?? '')),
+        });
+    }
+    return items.concat(replyItems.slice(0, limit));
+}