@jackwener/opencli 0.9.8 → 1.0.1

package/src/clis/twitter/notifications.ts

@@ -12,20 +12,30 @@ cli({
   ],
   columns: ['id', 'action', 'author', 'text', 'url'],
   func: async (page, kwargs) => {
-    // Install the interceptor before loading the notifications page so we
-    // capture the initial timeline request triggered during page load.
-    await page.goto('https://x.com');
-    await page.wait(2);
+    // 1. Navigate to home first (we need a loaded Twitter page for SPA navigation)
+    await page.goto('https://x.com/home');
+    await page.wait(3);
+
+    // 2. Install interceptor BEFORE SPA navigation
     await page.installInterceptor('NotificationsTimeline');
 
-    // 1. Navigate to notifications
-    await page.goto('https://x.com/notifications');
+    // 3. SPA navigate to notifications via history API
+    await page.evaluate(`() => {
+        window.history.pushState({}, '', '/notifications');
+        window.dispatchEvent(new PopStateEvent('popstate', { state: {} }));
+    }`);
     await page.wait(5);
 
-    // 3. Trigger API by scrolling (if we need to load more)
+    // Verify SPA navigation succeeded
+    const currentUrl = await page.evaluate('() => window.location.pathname');
+    if (currentUrl !== '/notifications') {
+        throw new Error('SPA navigation to notifications failed. Twitter may have changed its routing.');
+    }
+
+    // 4. Scroll to trigger pagination
     await page.autoScroll({ times: 2, delayMs: 2000 });
 
-    // 4. Retrieve data
+    // 5. Retrieve data
     const requests = await page.getInterceptedRequests();
     if (!requests || requests.length === 0) return [];
 
@@ -33,22 +43,20 @@ cli({
     const seen = new Set<string>();
     for (const req of requests) {
       try {
+        // GraphQL response: { data: { viewer: ... } } (one level of .data)
         let instructions: any[] = [];
-        if (req.data?.data?.viewer?.timeline_response?.timeline?.instructions) {
-             instructions = req.data.data.viewer.timeline_response.timeline.instructions;
-        } else if (req.data?.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
-             instructions = req.data.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
-        } else if (req.data?.data?.timeline?.instructions) {
-             instructions = req.data.data.timeline.instructions;
+        if (req.data?.viewer?.timeline_response?.timeline?.instructions) {
+             instructions = req.data.viewer.timeline_response.timeline.instructions;
+        } else if (req.data?.viewer_v2?.user_results?.result?.notification_timeline?.timeline?.instructions) {
+             instructions = req.data.viewer_v2.user_results.result.notification_timeline.timeline.instructions;
+        } else if (req.data?.timeline?.instructions) {
+             instructions = req.data.timeline.instructions;
         }
 
         let addEntries = instructions.find((i: any) => i.type === 'TimelineAddEntries');
-        
-        // Sometimes it's the first object without a 'type' field but has 'entries'
         if (!addEntries) {
              addEntries = instructions.find((i: any) => i.entries && Array.isArray(i.entries));
         }
-        
         if (!addEntries) continue;
 
         for (const entry of addEntries.entries) {
@@ -66,24 +74,22 @@ cli({
 
         function processNotificationItem(itemContent: any, entryId: string) {
             if (!itemContent) return;
-            
-            // Twitter wraps standard notifications 
+
             let item = itemContent?.notification_results?.result || itemContent?.tweet_results?.result || itemContent;
 
             let actionText = 'Notification';
             let author = 'unknown';
             let text = '';
             let urlStr = '';
-            
+
             if (item.__typename === 'TimelineNotification') {
-                 // Greet likes, retweet, mentions
                  text = item.rich_message?.text || item.message?.text || '';
                  const fromUser = item.template?.from_users?.[0]?.user_results?.result;
-                 author = fromUser?.legacy?.screen_name || fromUser?.core?.screen_name || 'unknown';
+                 // Twitter moved screen_name from legacy to core
+                 author = fromUser?.core?.screen_name || fromUser?.legacy?.screen_name || 'unknown';
                  urlStr = item.notification_url?.url || '';
                  actionText = item.notification_icon || 'Activity';
-                 
-                 // If there's an attached tweet
+
                  const targetTweet = item.template?.target_objects?.[0]?.tweet_results?.result;
                  if (targetTweet) {
                     const targetText = targetTweet.note_tweet?.note_tweet_results?.result?.text || targetTweet.legacy?.full_text || '';
@@ -93,14 +99,15 @@ cli({
                     }
                  }
             } else if (item.__typename === 'TweetNotification') {
-                 // Direct mention/reply
                  const tweet = item.tweet_result?.result;
-                 author = tweet?.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 const tweetUser = tweet?.core?.user_results?.result;
+                 author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                  text = tweet?.note_tweet?.note_tweet_results?.result?.text || tweet?.legacy?.full_text || item.message?.text || '';
                  actionText = 'Mention/Reply';
                  urlStr = `https://x.com/i/status/${tweet?.rest_id}`;
             } else if (item.__typename === 'Tweet') {
-                 author = item.core?.user_results?.result?.legacy?.screen_name || 'unknown';
+                 const tweetUser = item.core?.user_results?.result;
+                 author = tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown';
                  text = item.note_tweet?.note_tweet_results?.result?.text || item.legacy?.full_text || '';
                  actionText = 'Mention';
                  urlStr = `https://x.com/i/status/${item.rest_id}`;

package/src/clis/twitter/reply-dm.ts

@@ -0,0 +1,193 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'reply-dm',
+  description: 'Send a message to recent DM conversations',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  timeoutSeconds: 600, // 10 min — batch operation
+  args: [
+    { name: 'text', type: 'string', required: true, help: 'Message text to send (e.g. "我的微信 wxkabi")' },
+    { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of conversations to reply to (default: 20)' },
+    { name: 'skip-replied', type: 'boolean', required: false, default: true, help: 'Skip conversations where you already sent the same text (default: true)' },
+  ],
+  columns: ['index', 'status', 'user', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    const messageText: string = kwargs.text;
+    const maxSend: number = kwargs.max ?? 20;
+    const skipReplied: boolean = kwargs['skip-replied'] !== false;
+    const results: Array<{ index: number; status: string; user: string; message: string }> = [];
+    let sentCount = 0;
+
+    // Step 1: Navigate to messages to get conversation list
+    await page.goto('https://x.com/messages');
+    await page.wait(5);
+
+    // Step 2: Collect conversations with scroll-to-load
+    const needed = maxSend + 10; // extra buffer for skips
+    const convList = await page.evaluate(`(async () => {
+      try {
+        // Wait for initial items
+        let attempts = 0;
+        while (attempts < 10) {
+          const items = document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]');
+          if (items.length > 0) break;
+          await new Promise(r => setTimeout(r, 1000));
+          attempts++;
+        }
+
+        // Scroll to load more conversations
+        const needed = ${needed};
+        const seenIds = new Set();
+        let noNewCount = 0;
+
+        for (let scroll = 0; scroll < 30; scroll++) {
+          const items = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          items.forEach(el => seenIds.add(el.getAttribute('data-testid')));
+
+          if (seenIds.size >= needed) break;
+
+          // Find the scrollable container and scroll it
+          const scrollContainer = document.querySelector('[data-testid="dm-inbox-panel"]') ||
+                                  items[items.length - 1]?.closest('[class*="scroll"]') ||
+                                  items[items.length - 1]?.parentElement;
+          if (scrollContainer) {
+            scrollContainer.scrollTop = scrollContainer.scrollHeight;
+          }
+          // Also try scrolling the last item into view
+          if (items.length > 0) {
+            items[items.length - 1].scrollIntoView({ behavior: 'instant', block: 'end' });
+          }
+
+          await new Promise(r => setTimeout(r, 1500));
+
+          // Check if new items appeared
+          const newItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+          const newIds = new Set(newItems.map(el => el.getAttribute('data-testid')));
+          if (newIds.size <= seenIds.size) {
+            noNewCount++;
+            if (noNewCount >= 3) break; // No more loading after 3 tries
+          } else {
+            noNewCount = 0;
+          }
+        }
+
+        // Collect all visible conversations
+        const finalItems = Array.from(document.querySelectorAll('[data-testid^="dm-conversation-item-"], [data-testid="conversation"]'));
+        const conversations = finalItems.map((item, idx) => {
+          const testId = item.getAttribute('data-testid') || '';
+          const text = item.innerText || '';
+          const lines = text.split('\\n').filter(l => l.trim());
+          const user = lines[0] || 'Unknown';
+          const match = testId.match(/dm-conversation-item-(.+)/);
+          const convId = match ? match[1].replace(':', '-') : '';
+          const link = item.querySelector('a[href*="/messages/"]');
+          const href = link ? link.href : '';
+          return { idx, user, convId, href, preview: text.substring(0, 100) };
+        });
+
+        return { ok: true, conversations, total: conversations.length };
+      } catch(e) {
+        return { ok: false, error: String(e), conversations: [], total: 0 };
+      }
+    })()`);
+
+    if (!convList?.ok || !convList.conversations?.length) {
+      return [{ index: 1, status: 'info', user: 'System', message: 'No conversations found' }];
+    }
+
+    const conversations = convList.conversations;
+
+    // Step 3: Iterate through conversations and send message
+    for (const conv of conversations) {
+      if (sentCount >= maxSend) break;
+
+      const convUrl = conv.convId
+        ? `https://x.com/messages/${conv.convId}`
+        : conv.href;
+
+      if (!convUrl) continue;
+
+      await page.goto(convUrl);
+      await page.wait(3);
+
+      const sendResult = await page.evaluate(`(async () => {
+        try {
+          const messageText = ${JSON.stringify(messageText)};
+          const skipReplied = ${skipReplied};
+
+          // Get username from conversation
+          const dmHeader = document.querySelector('[data-testid="DmActivityContainer"] [dir="ltr"] span') ||
+                           document.querySelector('[data-testid="conversation-header"]') ||
+                           document.querySelector('[data-testid="DmActivityContainer"] h2');
+          const username = dmHeader ? dmHeader.innerText.trim().split('\\\\n')[0] : '${conv.user}';
+
+          // Check if we already sent this message
+          if (skipReplied) {
+            const chatArea = document.querySelector('[data-testid="DmScrollerContainer"]') ||
+                             document.querySelector('main');
+            const chatText = chatArea ? chatArea.innerText : '';
+            if (chatText.includes(messageText)) {
+              return { status: 'skipped', user: username, message: 'Already sent this message' };
+            }
+          }
+
+          // Find the text input
+          const input = document.querySelector('[data-testid="dmComposerTextInput"]');
+          if (!input) {
+            return { status: 'error', user: username, message: 'No message input found' };
+          }
+
+          // Focus and type into the DraftEditor
+          input.focus();
+          await new Promise(r => setTimeout(r, 300));
+          document.execCommand('insertText', false, messageText);
+          await new Promise(r => setTimeout(r, 500));
+
+          // Click send button
+          const sendBtn = document.querySelector('[data-testid="dmComposerSendButton"]');
+          if (!sendBtn) {
+            return { status: 'error', user: username, message: 'No send button found' };
+          }
+
+          sendBtn.click();
+          await new Promise(r => setTimeout(r, 1500));
+
+          return { status: 'sent', user: username, message: 'Message sent: ' + messageText };
+        } catch(e) {
+          return { status: 'error', user: 'system', message: String(e) };
+        }
+      })()`);
+
+      if (sendResult?.status === 'sent') {
+        sentCount++;
+        results.push({
+          index: sentCount,
+          status: 'sent',
+          user: sendResult.user || conv.user,
+          message: sendResult.message,
+        });
+      } else if (sendResult?.status === 'skipped') {
+        results.push({
+          index: results.length + 1,
+          status: 'skipped',
+          user: sendResult.user || conv.user,
+          message: sendResult.message,
+        });
+      }
+
+      await page.wait(1);
+    }
+
+    if (results.length === 0) {
+      results.push({ index: 0, status: 'info', user: 'System', message: 'No conversations processed' });
+    }
+
+    return results;
+  }
+});

package/src/clis/twitter/search.ts

@@ -13,21 +13,59 @@ cli({
   ],
   columns: ['id', 'author', 'text', 'likes', 'views', 'url'],
   func: async (page, kwargs) => {
-    // Install the interceptor before opening the target page so we don't miss
-    // the initial SearchTimeline request fired during hydration.
-    await page.goto('https://x.com');
-    await page.wait(2);
+    const query = kwargs.query;
+
+    // 1. Navigate to x.com/explore (has a search input at the top)
+    await page.goto('https://x.com/explore');
+    await page.wait(3);
+
+    // 2. Install interceptor BEFORE triggering search.
+    //    SPA navigation preserves the JS context, so the monkey-patched
+    //    fetch will capture the SearchTimeline API call.
     await page.installInterceptor('SearchTimeline');
 
-    // 1. Navigate to the search page
-    const q = encodeURIComponent(kwargs.query);
-    await page.goto(`https://x.com/search?q=${q}&f=top`);
+    // 3. Use the search input to submit the query (SPA, no full reload).
+    //    Find the search input, type the query, and submit.
+    await page.evaluate(`
+      (() => {
+        const input = document.querySelector('input[data-testid="SearchBox_Search_Input"]');
+        if (!input) throw new Error('Search input not found');
+        input.focus();
+        const nativeSetter = Object.getOwnPropertyDescriptor(
+          HTMLInputElement.prototype, 'value'
+        ).set;
+        nativeSetter.call(input, ${JSON.stringify(query)});
+        input.dispatchEvent(new Event('input', { bubbles: true }));
+      })()
+    `);
+    await page.wait(0.5);
+    // Press Enter to submit
+    await page.evaluate(`
+      (() => {
+        const input = document.querySelector('input[data-testid="SearchBox_Search_Input"]');
+        if (!input) throw new Error('Search input not found');
+        input.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', code: 'Enter', keyCode: 13, bubbles: true }));
+      })()
+    `);
     await page.wait(5);
 
-    // 3. Trigger API by scrolling
-    await page.autoScroll({ times: 3, delayMs: 2000 });
-    
-    // 4. Retrieve data
+    // 4. Click "Top" tab if available (ensures we get top results)
+    try {
+      await page.evaluate(`
+        (() => {
+          const tabs = document.querySelectorAll('[role="tab"]');
+          for (const tab of tabs) {
+            if (tab.textContent.trim() === 'Top') { tab.click(); break; }
+          }
+        })()
+      `);
+      await page.wait(2);
+    } catch { /* ignore if tab not found */ }
+
+    // 5. Scroll to trigger additional pagination
+    await page.autoScroll({ times: 2, delayMs: 2000 });
+
+    // 6. Retrieve captured data
     const requests = await page.getInterceptedRequests();
     if (!requests || requests.length === 0) return [];
 
@@ -35,7 +73,7 @@ cli({
     const seen = new Set<string>();
     for (const req of requests) {
       try {
-        const insts = req.data?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
+        const insts = req?.data?.search_by_raw_query?.search_timeline?.timeline?.instructions || [];
         const addEntries = insts.find((i: any) => i.type === 'TimelineAddEntries')
           || insts.find((i: any) => i.entries && Array.isArray(i.entries));
         if (!addEntries?.entries) continue;
@@ -53,9 +91,11 @@ cli({
           if (!tweet.rest_id || seen.has(tweet.rest_id)) continue;
           seen.add(tweet.rest_id);
 
+          // Twitter moved screen_name from legacy to core
+          const tweetUser = tweet.core?.user_results?.result;
           results.push({
             id: tweet.rest_id,
-            author: tweet.core?.user_results?.result?.legacy?.screen_name || 'unknown',
+            author: tweetUser?.core?.screen_name || tweetUser?.legacy?.screen_name || 'unknown',
             text: tweet.note_tweet?.note_tweet_results?.result?.text || tweet.legacy?.full_text || '',
             likes: tweet.legacy?.favorite_count || 0,
             views: tweet.views?.count || '0',

package/src/clis/weread/book.ts

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchWithPage } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'book',
+  description: 'View book details on WeRead',
+  domain: 'weread.qq.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bookId', positional: true, required: true, help: 'Book ID (numeric, from search or shelf results)' },
+  ],
+  columns: ['title', 'author', 'publisher', 'intro', 'category', 'rating'],
+  func: async (page: IPage, args) => {
+    const data = await fetchWithPage(page, '/book/info', { bookId: args.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,
+    }];
+  },
+});

package/src/clis/weread/highlights.ts

@@ -0,0 +1,25 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchWithPage, formatDate } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'highlights',
+  description: 'List your highlights (underlines) in a book',
+  domain: 'weread.qq.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bookId', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+  ],
+  columns: ['chapter', 'text', 'createTime'],
+  func: async (page: IPage, args) => {
+    const data = await fetchWithPage(page, '/book/bookmarklist', { bookId: args.bookId });
+    const items: any[] = data?.updated ?? [];
+    return items.slice(0, Number(args.limit)).map((item: any) => ({
+      chapter: item.chapterName ?? '',
+      text: item.markText ?? '',
+      createTime: formatDate(item.createTime),
+    }));
+  },
+});

package/src/clis/weread/notebooks.ts

@@ -0,0 +1,23 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchWithPage } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'notebooks',
+  description: 'List books that have highlights or notes',
+  domain: 'weread.qq.com',
+  strategy: Strategy.COOKIE,
+  columns: ['title', 'author', 'noteCount', 'bookId'],
+  func: async (page: IPage, _args) => {
+    const data = await fetchWithPage(page, '/user/notebooks');
+    const books: any[] = data?.books ?? [];
+    return books.map((item: any) => ({
+      title: item.book?.title ?? '',
+      author: item.book?.author ?? '',
+      // TODO: bookmarkCount/reviewCount field names from community docs, verify with real API
+      noteCount: (item.bookmarkCount ?? 0) + (item.reviewCount ?? 0),
+      bookId: item.bookId ?? '',
+    }));
+  },
+});

package/src/clis/weread/notes.ts

@@ -0,0 +1,31 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchWithPage, formatDate } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'notes',
+  description: 'List your notes (thoughts) on a book',
+  domain: 'weread.qq.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'bookId', positional: true, required: true, help: 'Book ID (from shelf or search results)' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+  ],
+  columns: ['chapter', 'text', 'review', 'createTime'],
+  func: async (page: IPage, args) => {
+    const data = await fetchWithPage(page, '/review/list', {
+      bookId: args.bookId,
+      listType: '11',
+      mine: '1',
+      synckey: '0',
+    });
+    const items: any[] = data?.reviews ?? [];
+    return items.slice(0, Number(args.limit)).map((item: any) => ({
+      chapter: item.review?.chapterName ?? '',
+      text: item.review?.abstract ?? '',
+      review: item.review?.content ?? '',
+      createTime: formatDate(item.review?.createTime),
+    }));
+  },
+});

package/src/clis/weread/ranking.ts

@@ -0,0 +1,29 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWebApi } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'ranking',
+  description: 'WeRead book rankings by category',
+  domain: 'weread.qq.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'category', positional: true, default: 'all', help: 'Category: all (default), rising, or numeric category ID' },
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+  ],
+  columns: ['rank', 'title', 'author', 'category', 'readingCount', 'bookId'],
+  func: async (_page, args) => {
+    const cat = encodeURIComponent(args.category ?? 'all');
+    const data = await fetchWebApi(`/bookListInCategory/${cat}`, { rank: '1' });
+    const books: any[] = data?.books ?? [];
+    return books.slice(0, Number(args.limit)).map((item: any, i: number) => ({
+      rank: i + 1,
+      title: item.bookInfo?.title ?? '',
+      author: item.bookInfo?.author ?? '',
+      category: item.bookInfo?.category ?? '',
+      readingCount: item.readingCount ?? 0,
+      bookId: item.bookInfo?.bookId ?? '',
+    }));
+  },
+});

package/src/clis/weread/search.ts

@@ -0,0 +1,26 @@
+import { cli, Strategy } from '../../registry.js';
+import { fetchWebApi } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'search',
+  description: 'Search books on WeRead',
+  domain: 'weread.qq.com',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+    { name: 'limit', type: 'int', default: 10, help: 'Max results' },
+  ],
+  columns: ['rank', 'title', 'author', 'bookId'],
+  func: async (_page, args) => {
+    const data = await fetchWebApi('/search/global', { keyword: args.keyword });
+    const books: any[] = data?.books ?? [];
+    return books.slice(0, Number(args.limit)).map((item: any, i: number) => ({
+      rank: i + 1,
+      title: item.bookInfo?.title ?? '',
+      author: item.bookInfo?.author ?? '',
+      bookId: item.bookInfo?.bookId ?? '',
+    }));
+  },
+});

package/src/clis/weread/shelf.ts

@@ -0,0 +1,26 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import { fetchWithPage } from './utils.js';
+
+cli({
+  site: 'weread',
+  name: 'shelf',
+  description: 'List books on your WeRead bookshelf',
+  domain: 'weread.qq.com',
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Max results' },
+  ],
+  columns: ['title', 'author', 'progress', 'bookId'],
+  func: async (page: IPage, args) => {
+    const data = await fetchWithPage(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 ?? '',
+    }));
+  },
+});