@jackwener/opencli 1.1.0 → 1.2.0

package/src/clis/twitter/download.ts

@@ -2,7 +2,7 @@
  * Twitter/X download — download images and videos from tweets.
  *
  * Usage:
- *   opencli twitter download --username elonmusk --limit 10 --output ./twitter
+ *   opencli twitter download elonmusk --limit 10 --output ./twitter
  *   opencli twitter download --tweet-url https://x.com/xxx/status/123 --output ./twitter
  */
 
@@ -27,7 +27,7 @@ cli({
   domain: 'x.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'username', help: 'Twitter username (downloads from media tab)' },
+    { name: 'username', positional: true, help: 'Twitter username (downloads from media tab)' },
     { name: 'tweet-url', help: 'Single tweet URL to download' },
     { name: 'limit', type: 'int', default: 10, help: 'Number of tweets to scan' },
     { name: 'output', default: './twitter-downloads', help: 'Output directory' },
@@ -44,7 +44,7 @@ cli({
         index: 0,
         type: '-',
         status: 'failed',
-        size: 'Must provide --username or --tweet-url',
+        size: 'Must provide a username or --tweet-url',
       }];
     }
 

package/src/clis/twitter/followers.ts

@@ -8,7 +8,7 @@ cli({
   strategy: Strategy.INTERCEPT,
   browser: true,
   args: [
-    { name: 'user', type: 'string', required: false },
+    { name: 'user', positional: true, type: 'string', required: false },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['screen_name', 'name', 'bio', 'followers'],

package/src/clis/twitter/following.ts

@@ -8,7 +8,7 @@ cli({
   strategy: Strategy.INTERCEPT,
   browser: true,
   args: [
-    { name: 'user', type: 'string', required: false },
+    { name: 'user', positional: true, type: 'string', required: false },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['screen_name', 'name', 'bio', 'followers'],

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

@@ -0,0 +1,70 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'hide-reply',
+  description: 'Hide a reply on your tweet (useful for hiding bot/spam replies)',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the reply tweet to hide' },
+  ],
+  columns: ['status', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+
+    await page.goto(kwargs.url);
+    await page.wait(5);
+
+    const result = await page.evaluate(`(async () => {
+        try {
+            let attempts = 0;
+            let moreMenu = null;
+
+            while (attempts < 20) {
+                moreMenu = document.querySelector('[aria-label="More"]');
+                if (moreMenu) break;
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!moreMenu) {
+                return { ok: false, message: 'Could not find the "More" menu on this tweet. Are you logged in?' };
+            }
+
+            moreMenu.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Look for the "Hide reply" menu item
+            const items = document.querySelectorAll('[role="menuitem"]');
+            let hideItem = null;
+            for (const item of items) {
+                if (item.textContent && item.textContent.includes('Hide reply')) {
+                    hideItem = item;
+                    break;
+                }
+            }
+
+            if (!hideItem) {
+                return { ok: false, message: 'Could not find "Hide reply" option. This may not be a reply on your tweet.' };
+            }
+
+            hideItem.click();
+            await new Promise(r => setTimeout(r, 1500));
+
+            return { ok: true, message: 'Reply successfully hidden.' };
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    if (result.ok) await page.wait(2);
+
+    return [{
+      status: result.ok ? 'success' : 'failed',
+      message: result.message
+    }];
+  }
+});

package/src/clis/twitter/like.ts

@@ -9,7 +9,7 @@ cli({
   strategy: Strategy.UI, // Utilizes internal DOM flows for interaction
   browser: true,
   args: [
-    { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to like' },
+    { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to like' },
   ],
   columns: ['status', 'message'],
   func: async (page: IPage | null, kwargs: any) => {

package/src/clis/twitter/post.ts

@@ -9,7 +9,7 @@ cli({
   strategy: Strategy.UI,
   browser: true,
   args: [
-    { name: 'text', type: 'string', required: true, help: 'The text content of the tweet' },
+    { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of the tweet' },
   ],
   columns: ['status', 'message', 'text'],
   func: async (page: IPage | null, kwargs: any) => {

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

@@ -10,7 +10,7 @@ cli({
   browser: true,
   timeoutSeconds: 600, // 10 min — batch operation
   args: [
-    { name: 'text', type: 'string', required: true, help: 'Message text to send (e.g. "我的微信 wxkabi")' },
+    { name: 'text', type: 'string', required: true, positional: 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)' },
   ],

package/src/clis/twitter/reply.ts

@@ -9,8 +9,8 @@ cli({
   strategy: Strategy.UI, // Uses the UI directly to input and click post
   browser: true,
   args: [
-    { name: 'url', type: 'string', required: true, help: 'The URL of the tweet to reply to' },
-    { name: 'text', type: 'string', required: true, help: 'The text content of your reply' },
+    { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to reply to' },
+    { name: 'text', type: 'string', required: true, positional: true, help: 'The text content of your reply' },
   ],
   columns: ['status', 'message', 'text'],
   func: async (page: IPage | null, kwargs: any) => {

package/src/clis/twitter/search.ts

@@ -8,7 +8,7 @@ cli({
   strategy: Strategy.INTERCEPT, // Use intercept strategy
   browser: true,
   args: [
-    { name: 'query', type: 'string', required: true },
+    { name: 'query', type: 'string', required: true, positional: true },
     { name: 'limit', type: 'int', default: 15 },
   ],
   columns: ['id', 'author', 'text', 'likes', 'views', 'url'],

package/src/clis/twitter/thread.ts

@@ -122,12 +122,12 @@ cli({
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
-    { name: 'tweet_id', type: 'string', required: true },
+    { name: 'tweet-id', positional: true, type: 'string', required: true },
     { name: 'limit', type: 'int', default: 50 },
   ],
   columns: ['id', 'author', 'text', 'likes', 'retweets', 'url'],
   func: async (page, kwargs) => {
-    let tweetId = kwargs.tweet_id;
+    let tweetId = kwargs['tweet-id'];
     const urlMatch = tweetId.match(/\/status\/(\d+)/);
     if (urlMatch) tweetId = urlMatch[1];
 

package/src/clis/twitter/timeline.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './timeline.js';
+
+describe('twitter timeline helpers', () => {
+  it('builds for-you variables with withCommunity', () => {
+    expect(__test__.buildTimelineVariables('for-you', 20)).toEqual({
+      count: 20,
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: 'launch',
+      withCommunity: true,
+    });
+  });
+
+  it('builds following variables with seenTweetIds instead of withCommunity', () => {
+    expect(__test__.buildTimelineVariables('following', 20, 'cursor-1')).toEqual({
+      count: 20,
+      includePromotedContent: false,
+      latestControlAvailable: true,
+      requestContext: 'launch',
+      seenTweetIds: [],
+      cursor: 'cursor-1',
+    });
+  });
+
+  it('encodes variables into timeline url', () => {
+    const url = __test__.buildHomeTimelineUrl('query123', 'HomeLatestTimeline', {
+      count: 20,
+      seenTweetIds: [],
+    });
+
+    expect(url).toContain('/i/api/graphql/query123/HomeLatestTimeline');
+    expect(url).toContain('variables=');
+    expect(url).toContain('features=');
+    expect(decodeURIComponent(url)).toContain('"seenTweetIds":[]');
+  });
+
+  it('parses tweets and bottom cursor from home timeline payload', () => {
+    const payload = {
+      data: {
+        home: {
+          home_timeline_urt: {
+            instructions: [
+              {
+                entries: [
+                  {
+                    entryId: 'tweet-1',
+                    content: {
+                      itemContent: {
+                        tweet_results: {
+                          result: {
+                            rest_id: '1',
+                            legacy: {
+                              full_text: 'hello',
+                              favorite_count: 3,
+                              retweet_count: 2,
+                              reply_count: 1,
+                              created_at: 'now',
+                            },
+                            core: {
+                              user_results: {
+                                result: {
+                                  legacy: {
+                                    screen_name: 'alice',
+                                  },
+                                },
+                              },
+                            },
+                            views: {
+                              count: '9',
+                            },
+                          },
+                        },
+                      },
+                    },
+                  },
+                  {
+                    entryId: 'cursor-bottom-1',
+                    content: {
+                      entryType: 'TimelineTimelineCursor',
+                      cursorType: 'Bottom',
+                      value: 'cursor-next',
+                    },
+                  },
+                ],
+              },
+            ],
+          },
+        },
+      },
+    };
+
+    const result = __test__.parseHomeTimeline(payload, new Set());
+
+    expect(result.nextCursor).toBe('cursor-next');
+    expect(result.tweets).toHaveLength(1);
+    expect(result.tweets[0]).toMatchObject({
+      id: '1',
+      author: 'alice',
+      text: 'hello',
+      likes: 3,
+      retweets: 2,
+      replies: 1,
+      views: 9,
+      created_at: 'now',
+      url: 'https://x.com/alice/status/1',
+    });
+  });
+});

package/src/clis/twitter/timeline.ts

@@ -2,8 +2,24 @@ import { cli, Strategy } from '../../registry.js';
 
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 
-const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+const BEARER_TOKEN =
+  'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
+const HOME_LATEST_TIMELINE_QUERY_ID = 'BKB7oi212Fi7kQtCBGE4zA';
+
+type TimelineType = 'for-you' | 'following';
+
+interface TimelineEndpointConfig {
+  endpoint: string;
+  method: 'GET' | 'POST';
+  fallbackQueryId: string;
+}
+
+// Endpoint config: for-you uses GET HomeTimeline, following uses POST HomeLatestTimeline
+const TIMELINE_ENDPOINTS: Record<TimelineType, TimelineEndpointConfig> = {
+  'for-you': { endpoint: 'HomeTimeline', method: 'GET', fallbackQueryId: HOME_TIMELINE_QUERY_ID },
+  following: { endpoint: 'HomeLatestTimeline', method: 'POST', fallbackQueryId: HOME_LATEST_TIMELINE_QUERY_ID },
+};
 
 const FEATURES = {
   rweb_video_screen_enabled: false,
@@ -53,19 +69,26 @@ interface TimelineTweet {
   url: string;
 }
 
-function buildHomeTimelineUrl(count: number, cursor?: string | null): string {
-  const vars: Record<string, any> = {
+function buildTimelineVariables(type: TimelineType, count: number, cursor?: string | null): Record<string, unknown> {
+  const vars: Record<string, unknown> = {
     count,
     includePromotedContent: false,
     latestControlAvailable: true,
     requestContext: 'launch',
-    withCommunity: true,
   };
+  if (type === 'for-you') vars.withCommunity = true;
+  if (type === 'following') vars.seenTweetIds = [];
   if (cursor) vars.cursor = cursor;
+  return vars;
+}
+
+function buildHomeTimelineUrl(queryId: string, endpoint: string, vars: Record<string, unknown>): string {
 
-  return `/i/api/graphql/${HOME_TIMELINE_QUERY_ID}/HomeTimeline`
-    + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
-    + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+  return (
+    `/i/api/graphql/${queryId}/${endpoint}` +
+    `?variables=${encodeURIComponent(JSON.stringify(vars))}` +
+    `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`
+  );
 }
 
 function extractTweet(result: any, seen: Set<string>): TimelineTweet | null {
@@ -97,8 +120,8 @@ function parseHomeTimeline(data: any, seen: Set<string>): { tweets: TimelineTwee
   const tweets: TimelineTweet[] = [];
   let nextCursor: string | null = null;
 
-  const instructions =
-    data?.data?.home?.home_timeline_urt?.instructions || [];
+  // Both HomeTimeline and HomeLatestTimeline share the same response envelope
+  const instructions = data?.data?.home?.home_timeline_urt?.instructions || [];
 
   for (const inst of instructions) {
     for (const entry of inst.entries || []) {
@@ -144,16 +167,24 @@ function parseHomeTimeline(data: any, seen: Set<string>): { tweets: TimelineTwee
 cli({
   site: 'twitter',
   name: 'timeline',
-  description: 'Fetch Twitter Home Timeline',
+  description: 'Fetch Twitter timeline (for-you or following)',
   domain: 'x.com',
   strategy: Strategy.COOKIE,
   browser: true,
   args: [
+    {
+      name: 'type',
+      default: 'for-you',
+      choices: ['for-you', 'following'],
+      help: 'Timeline type: for-you (algorithmic) or following (chronological)',
+    },
     { name: 'limit', type: 'int', default: 20 },
   ],
   columns: ['id', 'author', 'text', 'likes', 'retweets', 'replies', 'views', 'created_at', 'url'],
   func: async (page, kwargs) => {
     const limit = kwargs.limit || 20;
+    const timelineType: TimelineType = kwargs.type === 'following' ? 'following' : 'for-you';
+    const { endpoint, method, fallbackQueryId } = TIMELINE_ENDPOINTS[timelineType];
 
     // Navigate to x.com for cookie context
     await page.goto('https://x.com');
@@ -165,22 +196,24 @@ cli({
     }`);
     if (!ct0) throw new Error('Not logged into x.com (no ct0 cookie)');
 
-    // Dynamically resolve queryId
-    const queryId = await page.evaluate(`async () => {
+    // Dynamically resolve queryId for the selected endpoint
+    const resolved = await page.evaluate(`async () => {
       try {
         const ghResp = await fetch('https://raw.githubusercontent.com/fa0311/twitter-openapi/refs/heads/main/src/config/placeholder.json');
         if (ghResp.ok) {
           const data = await ghResp.json();
-          const entry = data['HomeTimeline'];
+          const entry = data['${endpoint}'];
           if (entry && entry.queryId) return entry.queryId;
         }
       } catch {}
       return null;
-    }`) || HOME_TIMELINE_QUERY_ID;
+    }`);
+    // Validate queryId format to prevent injection from untrusted upstream
+    const queryId = typeof resolved === 'string' && /^[A-Za-z0-9_-]+$/.test(resolved) ? resolved : fallbackQueryId;
 
     // Build auth headers
     const headers = JSON.stringify({
-      'Authorization': `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
+      Authorization: `Bearer ${decodeURIComponent(BEARER_TOKEN)}`,
       'X-Csrf-Token': ct0,
       'X-Twitter-Auth-Type': 'OAuth2Session',
       'X-Twitter-Active-User': 'yes',
@@ -193,16 +226,17 @@ cli({
 
     for (let i = 0; i < 5 && allTweets.length < limit; i++) {
       const fetchCount = Math.min(40, limit - allTweets.length + 5); // over-fetch slightly for promoted filtering
-      const apiUrl = buildHomeTimelineUrl(fetchCount, cursor)
-        .replace(HOME_TIMELINE_QUERY_ID, queryId);
+      const variables = buildTimelineVariables(timelineType, fetchCount, cursor);
+      const apiUrl = buildHomeTimelineUrl(queryId, endpoint, variables);
 
       const data = await page.evaluate(`async () => {
-        const r = await fetch("${apiUrl}", { headers: ${headers}, credentials: 'include' });
+        const r = await fetch("${apiUrl}", { method: "${method}", headers: ${headers}, credentials: 'include' });
         return r.ok ? await r.json() : { error: r.status };
       }`);
 
       if (data?.error) {
-        if (allTweets.length === 0) throw new Error(`HTTP ${data.error}: Failed to fetch timeline. queryId may have expired.`);
+        if (allTweets.length === 0)
+          throw new Error(`HTTP ${data.error}: Failed to fetch timeline. queryId may have expired.`);
         break;
       }
 
@@ -216,3 +250,9 @@ cli({
     return allTweets.slice(0, limit);
   },
 });
+
+export const __test__ = {
+  buildTimelineVariables,
+  buildHomeTimelineUrl,
+  parseHomeTimeline,
+};

package/src/clis/twitter/trending.ts

@@ -0,0 +1,113 @@
+import { cli, Strategy } from '../../registry.js';
+
+// ── Twitter GraphQL constants ──────────────────────────────────────────
+
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+
+// ── Types ──────────────────────────────────────────────────────────────
+
+interface TrendItem {
+  rank: number;
+  topic: string;
+  tweets: string;
+  category: string;
+}
+
+// ── CLI definition ────────────────────────────────────────────────────
+
+cli({
+  site: 'twitter',
+  name: 'trending',
+  description: 'Twitter/X trending topics',
+  domain: 'x.com',
+  strategy: Strategy.COOKIE,
+  browser: true,
+  args: [
+    { name: 'limit', type: 'int', default: 20, help: 'Number of trends to show' },
+  ],
+  columns: ['rank', 'topic', 'tweets', 'category'],
+  func: async (page, kwargs) => {
+    const limit = kwargs.limit || 20;
+
+    // Navigate to trending page
+    await page.goto('https://x.com/explore/tabs/trending');
+    await page.wait(3);
+
+    // Extract CSRF token to verify login
+    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 Error('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'
+        }
+      });
+      return r.ok ? await r.json() : null;
+    })()`);
+
+    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 Error('No trending data found. API may have changed or login may be required.');
+    }
+
+    return trends.slice(0, limit);
+  },
+});

package/src/clis/twitter/unblock.ts

@@ -0,0 +1,75 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.js';
+
+cli({
+  site: 'twitter',
+  name: 'unblock',
+  description: 'Unblock a Twitter user',
+  domain: 'x.com',
+  strategy: Strategy.UI,
+  browser: true,
+  args: [
+    { name: 'username', type: 'string', positional: true, required: true, help: 'Twitter screen name (without @)' },
+  ],
+  columns: ['status', 'message'],
+  func: async (page: IPage | null, kwargs: any) => {
+    if (!page) throw new Error('Requires browser');
+    const username = kwargs.username.replace(/^@/, '');
+
+    await page.goto(`https://x.com/${username}`);
+    await page.wait(5);
+
+    const result = await page.evaluate(`(async () => {
+        try {
+            let attempts = 0;
+            let unblockBtn = null;
+
+            while (attempts < 20) {
+                // Check if not blocked (follow button visible means not blocked)
+                const followBtn = document.querySelector('[data-testid$="-follow"]');
+                if (followBtn) {
+                    return { ok: true, message: 'Not blocking @${username} (already unblocked).' };
+                }
+
+                unblockBtn = document.querySelector('[data-testid$="-unblock"]');
+                if (unblockBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            if (!unblockBtn) {
+                return { ok: false, message: 'Could not find Unblock button. Are you logged in?' };
+            }
+
+            // Click the unblock button — this opens a confirmation dialog
+            unblockBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Confirm the unblock in the dialog
+            const confirmBtn = document.querySelector('[data-testid="confirmationSheetConfirm"]');
+            if (confirmBtn) {
+                confirmBtn.click();
+                await new Promise(r => setTimeout(r, 1000));
+            }
+
+            // Verify
+            const verify = document.querySelector('[data-testid$="-follow"]');
+            if (verify) {
+                return { ok: true, message: 'Successfully unblocked @${username}.' };
+            } else {
+                return { ok: false, message: 'Unblock action initiated but UI did not update.' };
+            }
+        } catch (e) {
+            return { ok: false, message: e.toString() };
+        }
+    })()`);
+
+    if (result.ok) await page.wait(2);
+
+    return [{
+      status: result.ok ? 'success' : 'failed',
+      message: result.message
+    }];
+  }
+});

package/src/clis/v2ex/topic.yaml

@@ -7,6 +7,7 @@ browser: false
 
 args:
   id:
+    positional: true
     type: str
     required: true
     description: Topic ID

package/src/clis/weibo/hot.ts

@@ -17,7 +17,6 @@ cli({
   func: async (page, kwargs) => {
     const count = Math.min(kwargs.limit || 30, 50);
     await page.goto('https://weibo.com');
-    await page.wait(2);
     const data = await page.evaluate(`
       (async () => {
         const resp = await fetch('/ajax/statuses/hot_band', {credentials: 'include'});

package/src/clis/weread/book.ts

@@ -9,7 +9,7 @@ cli({
   domain: 'weread.qq.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'bookId', positional: true, required: true, help: 'Book ID (numeric, from search or shelf results)' },
+    { name: 'book-id', 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) => {