@jackwener/opencli 1.1.0 → 1.2.0

package/dist/clis/twitter/download.js

@@ -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
  */
 import * as fs from 'node:fs';
@@ -17,7 +17,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' },
@@ -33,7 +33,7 @@ cli({
                     index: 0,
                     type: '-',
                     status: 'failed',
-                    size: 'Must provide --username or --tweet-url',
+                    size: 'Must provide a username or --tweet-url',
                 }];
         }
         // Navigate to the appropriate page

package/dist/clis/twitter/followers.js

@@ -7,7 +7,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/dist/clis/twitter/following.js

@@ -7,7 +7,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/dist/clis/twitter/hide-reply.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/hide-reply.js

@@ -0,0 +1,66 @@
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        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/dist/clis/twitter/like.js

@@ -7,7 +7,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, kwargs) => {

package/dist/clis/twitter/post.js

@@ -7,7 +7,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, kwargs) => {

package/dist/clis/twitter/reply-dm.js

@@ -8,7 +8,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/dist/clis/twitter/reply.js

@@ -7,8 +7,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, kwargs) => {

package/dist/clis/twitter/search.js

@@ -7,7 +7,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/dist/clis/twitter/thread.js

@@ -97,12 +97,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/dist/clis/twitter/timeline.d.ts

@@ -1 +1,24 @@
+type TimelineType = 'for-you' | 'following';
+interface TimelineTweet {
+    id: string;
+    author: string;
+    text: string;
+    likes: number;
+    retweets: number;
+    replies: number;
+    views: number;
+    created_at: string;
+    url: string;
+}
+declare function buildTimelineVariables(type: TimelineType, count: number, cursor?: string | null): Record<string, unknown>;
+declare function buildHomeTimelineUrl(queryId: string, endpoint: string, vars: Record<string, unknown>): string;
+declare function parseHomeTimeline(data: any, seen: Set<string>): {
+    tweets: TimelineTweet[];
+    nextCursor: string | null;
+};
+export declare const __test__: {
+    buildTimelineVariables: typeof buildTimelineVariables;
+    buildHomeTimelineUrl: typeof buildHomeTimelineUrl;
+    parseHomeTimeline: typeof parseHomeTimeline;
+};
 export {};

package/dist/clis/twitter/timeline.js

@@ -2,6 +2,12 @@ import { cli, Strategy } from '../../registry.js';
 // ── Twitter GraphQL constants ──────────────────────────────────────────
 const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
 const HOME_TIMELINE_QUERY_ID = 'c-CzHF1LboFilMpsx4ZCrQ';
+const HOME_LATEST_TIMELINE_QUERY_ID = 'BKB7oi212Fi7kQtCBGE4zA';
+// Endpoint config: for-you uses GET HomeTimeline, following uses POST HomeLatestTimeline
+const TIMELINE_ENDPOINTS = {
+    '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,
     profile_label_improvements_pcf_label_in_post_enabled: true,
@@ -35,19 +41,25 @@ const FEATURES = {
     responsive_web_grok_image_annotation_enabled: true,
     responsive_web_enhance_cards_enabled: false,
 };
-function buildHomeTimelineUrl(count, cursor) {
+function buildTimelineVariables(type, count, cursor) {
     const vars = {
         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 `/i/api/graphql/${HOME_TIMELINE_QUERY_ID}/HomeTimeline`
-        + `?variables=${encodeURIComponent(JSON.stringify(vars))}`
-        + `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`;
+    return vars;
+}
+function buildHomeTimelineUrl(queryId, endpoint, vars) {
+    return (`/i/api/graphql/${queryId}/${endpoint}` +
+        `?variables=${encodeURIComponent(JSON.stringify(vars))}` +
+        `&features=${encodeURIComponent(JSON.stringify(FEATURES))}`);
 }
 function extractTweet(result, seen) {
     if (!result)
@@ -76,6 +88,7 @@ function extractTweet(result, seen) {
 function parseHomeTimeline(data, seen) {
     const tweets = [];
     let nextCursor = null;
+    // 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 || []) {
@@ -120,16 +133,24 @@ function parseHomeTimeline(data, seen) {
 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 = 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');
         await page.wait(3);
@@ -139,21 +160,23 @@ 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',
@@ -164,10 +187,10 @@ cli({
         let cursor = null;
         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) {
@@ -184,3 +207,8 @@ cli({
         return allTweets.slice(0, limit);
     },
 });
+export const __test__ = {
+    buildTimelineVariables,
+    buildHomeTimelineUrl,
+    parseHomeTimeline,
+};

package/dist/clis/twitter/timeline.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/timeline.test.js

@@ -0,0 +1,102 @@
+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/dist/clis/twitter/trending.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/trending.js

@@ -0,0 +1,91 @@
+import { cli, Strategy } from '../../registry.js';
+// ── Twitter GraphQL constants ──────────────────────────────────────────
+const BEARER_TOKEN = 'AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA';
+// ── 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 = [];
+        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) => inst?.addEntries?.entries || inst?.entries || []);
+            const apiTrends = entries
+                .filter((e) => e.content?.timelineModule)
+                .flatMap((e) => e.content.timelineModule.items || [])
+                .map((t) => t?.item?.content?.trend)
+                .filter(Boolean);
+            trends = apiTrends.map((t, i) => ({
+                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/dist/clis/twitter/unblock.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/clis/twitter/unblock.js

@@ -0,0 +1,71 @@
+import { cli, Strategy } from '../../registry.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, kwargs) => {
+        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/dist/clis/v2ex/topic.yaml

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

package/dist/clis/weibo/hot.js

@@ -16,7 +16,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/dist/clis/weread/book.js

@@ -7,7 +7,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, args) => {

package/dist/clis/weread/highlights.js

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