@jackwener/opencli 1.5.0 → 1.5.2

package/src/clis/apple-podcasts/commands.test.ts

@@ -38,13 +38,14 @@ describe('apple-podcasts search command', () => {
       'https://itunes.apple.com/search?term=machine%20learning&media=podcast&limit=5',
     );
     expect(result).toEqual([
-      {
+      expect.objectContaining({
         id: 42,
         title: 'Machine Learning Guide',
         author: 'OpenCLI',
         episodes: 12,
         genre: 'Technology',
-      },
+        url: '',
+      }),
     ]);
   });
 });
@@ -54,6 +55,30 @@ describe('apple-podcasts top command', () => {
     vi.restoreAllMocks();
   });
 
+  it('adds a timeout signal to chart fetches', async () => {
+    const cmd = getRegistry().get('apple-podcasts/top');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        feed: {
+          results: [
+            { id: '100', name: 'Top Show', artistName: 'Host A' },
+          ],
+        },
+      }),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await cmd!.func!(null as any, { country: 'US', limit: 1 });
+
+    const [, options] = fetchMock.mock.calls[0] ?? [];
+    expect(options).toBeDefined();
+    expect(options.signal).toBeDefined();
+    expect(options.signal).toHaveProperty('aborted', false);
+  });
+
   it('uses the canonical Apple charts host and maps ranked results', async () => {
     const cmd = getRegistry().get('apple-podcasts/top');
     expect(cmd?.func).toBeTypeOf('function');
@@ -75,6 +100,9 @@ describe('apple-podcasts top command', () => {
 
     expect(fetchMock).toHaveBeenCalledWith(
       'https://rss.marketingtools.apple.com/api/v2/us/podcasts/top/2/podcasts.json',
+      expect.objectContaining({
+        signal: expect.any(Object),
+      }),
     );
     expect(result).toEqual([
       { rank: 1, title: 'Top Show', author: 'Host A', id: '100' },

package/src/clis/apple-podcasts/top.ts

@@ -3,6 +3,7 @@ import { CliError } from '../../errors.js';
 
 // Apple Marketing Tools RSS API — public, no key required
 const CHARTS_URL = 'https://rss.marketingtools.apple.com/api/v2';
+const CHARTS_TIMEOUT_MS = 15_000;
 
 cli({
   site: 'apple-podcasts',
@@ -21,7 +22,9 @@ cli({
     const url = `${CHARTS_URL}/${country}/podcasts/top/${limit}/podcasts.json`;
     let resp: Response;
     try {
-      resp = await fetch(url);
+      resp = await fetch(url, {
+        signal: AbortSignal.timeout(CHARTS_TIMEOUT_MS),
+      });
     } catch (error: any) {
       const reason = error?.cause?.code ?? error?.message ?? 'unknown network error';
       throw new CliError(

package/src/clis/bluesky/feeds.yaml

@@ -0,0 +1,29 @@
+site: bluesky
+name: feeds
+description: Popular Bluesky feed generators
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of feeds
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.unspecced.getPopularFeedGenerators?limit=${{ args.limit }}
+
+  - select: feeds
+
+  - map:
+      rank: ${{ index + 1 }}
+      name: ${{ item.displayName }}
+      likes: ${{ item.likeCount }}
+      creator: ${{ item.creator.handle }}
+      description: ${{ item.description }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, name, likes, creator, description]

package/src/clis/bluesky/followers.yaml

@@ -0,0 +1,33 @@
+site: bluesky
+name: followers
+description: List followers of a Bluesky user
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  handle:
+    type: str
+    required: true
+    positional: true
+    description: "Bluesky handle"
+  limit:
+    type: int
+    default: 20
+    description: Number of followers
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.graph.getFollowers?actor=${{ args.handle }}&limit=${{ args.limit }}
+
+  - select: followers
+
+  - map:
+      rank: ${{ index + 1 }}
+      handle: ${{ item.handle }}
+      name: ${{ item.displayName }}
+      description: ${{ item.description }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, handle, name, description]

package/src/clis/bluesky/following.yaml

@@ -0,0 +1,33 @@
+site: bluesky
+name: following
+description: List accounts a Bluesky user is following
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  handle:
+    type: str
+    required: true
+    positional: true
+    description: "Bluesky handle"
+  limit:
+    type: int
+    default: 20
+    description: Number of accounts
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.graph.getFollows?actor=${{ args.handle }}&limit=${{ args.limit }}
+
+  - select: follows
+
+  - map:
+      rank: ${{ index + 1 }}
+      handle: ${{ item.handle }}
+      name: ${{ item.displayName }}
+      description: ${{ item.description }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, handle, name, description]

package/src/clis/bluesky/profile.yaml

@@ -0,0 +1,27 @@
+site: bluesky
+name: profile
+description: Get Bluesky user profile info
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  handle:
+    type: str
+    required: true
+    positional: true
+    description: "Bluesky handle (e.g. bsky.app, jay.bsky.team)"
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor=${{ args.handle }}
+
+  - map:
+      handle: ${{ item.handle }}
+      name: ${{ item.displayName }}
+      followers: ${{ item.followersCount }}
+      following: ${{ item.followsCount }}
+      posts: ${{ item.postsCount }}
+      description: ${{ item.description }}
+
+columns: [handle, name, followers, following, posts, description]

package/src/clis/bluesky/search.yaml

@@ -0,0 +1,34 @@
+site: bluesky
+name: search
+description: Search Bluesky users
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  query:
+    type: str
+    required: true
+    positional: true
+    description: Search query
+  limit:
+    type: int
+    default: 10
+    description: Number of results
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.actor.searchActors?q=${{ args.query }}&limit=${{ args.limit }}
+
+  - select: actors
+
+  - map:
+      rank: ${{ index + 1 }}
+      handle: ${{ item.handle }}
+      name: ${{ item.displayName }}
+      followers: ${{ item.followersCount }}
+      description: ${{ item.description }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, handle, name, followers, description]

package/src/clis/bluesky/starter-packs.yaml

@@ -0,0 +1,34 @@
+site: bluesky
+name: starter-packs
+description: Get starter packs created by a Bluesky user
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  handle:
+    type: str
+    required: true
+    positional: true
+    description: "Bluesky handle"
+  limit:
+    type: int
+    default: 10
+    description: Number of starter packs
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.graph.getActorStarterPacks?actor=${{ args.handle }}&limit=${{ args.limit }}
+
+  - select: starterPacks
+
+  - map:
+      rank: ${{ index + 1 }}
+      name: ${{ item.record.name }}
+      description: ${{ item.record.description }}
+      members: ${{ item.listItemCount }}
+      joins: ${{ item.joinedAllTimeCount }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, name, description, members, joins]

package/src/clis/bluesky/thread.yaml

@@ -0,0 +1,32 @@
+site: bluesky
+name: thread
+description: Get a Bluesky post thread with replies
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  uri:
+    type: str
+    required: true
+    positional: true
+    description: "Post AT URI (at://did:.../app.bsky.feed.post/...) or bsky.app URL"
+  limit:
+    type: int
+    default: 20
+    description: Number of replies
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.feed.getPostThread?uri=${{ args.uri }}&depth=2
+
+  - select: thread
+
+  - map:
+      author: ${{ item.post.author.handle }}
+      text: ${{ item.post.record.text }}
+      likes: ${{ item.post.likeCount }}
+      reposts: ${{ item.post.repostCount }}
+      replies_count: ${{ item.post.replyCount }}
+
+columns: [author, text, likes, reposts, replies_count]

package/src/clis/bluesky/trending.yaml

@@ -0,0 +1,27 @@
+site: bluesky
+name: trending
+description: Trending topics on Bluesky
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  limit:
+    type: int
+    default: 20
+    description: Number of topics
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.unspecced.getTrendingTopics
+
+  - select: topics
+
+  - map:
+      rank: ${{ index + 1 }}
+      topic: ${{ item.topic }}
+      link: ${{ item.link }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, topic, link]

package/src/clis/bluesky/user.yaml

@@ -0,0 +1,34 @@
+site: bluesky
+name: user
+description: Get recent posts from a Bluesky user
+domain: public.api.bsky.app
+strategy: public
+browser: false
+
+args:
+  handle:
+    type: str
+    required: true
+    positional: true
+    description: "Bluesky handle (e.g. bsky.app)"
+  limit:
+    type: int
+    default: 20
+    description: Number of posts
+
+pipeline:
+  - fetch:
+      url: https://public.api.bsky.app/xrpc/app.bsky.feed.getAuthorFeed?actor=${{ args.handle }}&limit=${{ args.limit }}
+
+  - select: feed
+
+  - map:
+      rank: ${{ index + 1 }}
+      text: ${{ item.post.record.text }}
+      likes: ${{ item.post.likeCount }}
+      reposts: ${{ item.post.repostCount }}
+      replies: ${{ item.post.replyCount }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, text, likes, reposts, replies]

package/src/clis/twitter/trending.ts

@@ -1,19 +1,6 @@
 import { cli, Strategy } from '../../registry.js';
 import { AuthRequiredError, EmptyResultError } from '../../errors.js';
 
-// ── Twitter GraphQL constants ──────────────────────────────────────────
-
-const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
-
-// ── Types ──────────────────────────────────────────────────────────────
-
-interface TrendItem {
-  rank: number;
-  topic: string;
-  tweets: string;
-  category: string;
-}
-
 // ── CLI definition ────────────────────────────────────────────────────
 
 cli({
@@ -34,79 +21,44 @@ cli({
     await page.goto('https://x.com/explore/tabs/trending');
     await page.wait(3);
 
-    // Extract CSRF token to verify login
+    // Verify login via CSRF cookie
     const ct0 = await page.evaluate(`(() => {
       return document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1] || null;
     })()`);
     if (!ct0) throw new AuthRequiredError('x.com', 'Not logged into x.com (no ct0 cookie)');
 
-    // Try legacy guide.json API first (faster than DOM scraping)
-    let trends: TrendItem[] = [];
-
-    const apiData = await page.evaluate(`(async () => {
-      const ct0 = document.cookie.split(';').map(c=>c.trim()).find(c=>c.startsWith('ct0='))?.split('=')[1] || '';
-      const r = await fetch('/i/api/2/guide.json?include_page_configuration=true', {
-        credentials: 'include',
-        headers: {
-          'x-twitter-active-user': 'yes',
-          'x-csrf-token': ct0,
-          'authorization': 'Bearer AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA'
+    // Scrape trends from DOM (consistent with what the user sees on the page)
+    // DOM children: [0] rank + category, [1] topic, optional post count,
+    // and a caret menu button identified by [data-testid="caret"].
+    await page.wait(2);
+    const trends = await page.evaluate(`(() => {
+      const items = [];
+      const cells = document.querySelectorAll('[data-testid="trend"]');
+      cells.forEach((cell) => {
+        const text = cell.textContent || '';
+        if (text.includes('Promoted')) return;
+        const container = cell.querySelector(':scope > div');
+        if (!container) return;
+        const divs = container.children;
+        if (divs.length < 2) return;
+        const topic = divs[1].textContent.trim();
+        if (!topic) return;
+        const catText = divs[0].textContent.trim();
+        const category = catText.replace(/^\\d+\\s*/, '').replace(/^\\xB7\\s*/, '').trim();
+        // Find post count: skip rank, topic, and the caret menu button
+        let tweets = 'N/A';
+        for (let j = 2; j < divs.length; j++) {
+          if (divs[j].matches('[data-testid="caret"]') || divs[j].querySelector('[data-testid="caret"]')) continue;
+          const t = divs[j].textContent.trim();
+          if (t && /\\d/.test(t)) { tweets = t; break; }
         }
+        items.push({ rank: items.length + 1, topic, tweets, category });
       });
-      return r.ok ? await r.json() : null;
+      return items;
     })()`);
 
-    if (apiData) {
-      const instructions = apiData?.timeline?.instructions || [];
-      const entries = instructions.flatMap((inst: any) => inst?.addEntries?.entries || inst?.entries || []);
-      const apiTrends = entries
-        .filter((e: any) => e.content?.timelineModule)
-        .flatMap((e: any) => e.content.timelineModule.items || [])
-        .map((t: any) => t?.item?.content?.trend)
-        .filter(Boolean);
-
-      trends = apiTrends.map((t: any, i: number) => ({
-        rank: i + 1,
-        topic: t.name,
-        tweets: t.tweetCount ? String(t.tweetCount) : 'N/A',
-        category: t.trendMetadata?.domainContext || '',
-      }));
-    }
-
-    // Fallback: scrape from the loaded DOM
-    if (trends.length === 0) {
-      await page.wait(2);
-      const domTrends = await page.evaluate(`(() => {
-        const items = [];
-        const cells = document.querySelectorAll('[data-testid="trend"]');
-        cells.forEach((cell) => {
-          const text = cell.textContent || '';
-          if (text.includes('Promoted')) return;
-          const container = cell.querySelector(':scope > div');
-          if (!container) return;
-          const divs = container.children;
-          // Structure: divs[0] = rank + category, divs[1] = topic name, divs[2] = extra
-          const topicEl = divs.length >= 2 ? divs[1] : null;
-          const topic = topicEl ? topicEl.textContent.trim() : '';
-          const catEl = divs.length >= 1 ? divs[0] : null;
-          const catText = catEl ? catEl.textContent.trim() : '';
-          const category = catText.replace(/^\\d+\\s*/, '').replace(/^\\xB7\\s*/, '').trim();
-          const extraEl = divs.length >= 3 ? divs[2] : null;
-          const extra = extraEl ? extraEl.textContent.trim() : '';
-          if (topic) {
-            items.push({ rank: items.length + 1, topic, tweets: extra || 'N/A', category });
-          }
-        });
-        return items;
-      })()`);
-
-      if (Array.isArray(domTrends) && domTrends.length > 0) {
-        trends = domTrends;
-      }
-    }
-
-    if (trends.length === 0) {
-      throw new EmptyResultError('twitter trending', 'API may have changed or login may be required.');
+    if (!Array.isArray(trends) || trends.length === 0) {
+      throw new EmptyResultError('twitter trending', 'No trends found. The page structure may have changed.');
     }
 
     return trends.slice(0, limit);

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);
+    }
   },
 });