@jackwener/opencli 1.1.0 → 1.1.1

package/dist/clis/steam/top-sellers.yaml

@@ -0,0 +1,29 @@
+site: steam
+name: top-sellers
+description: Steam top selling games
+domain: store.steampowered.com
+strategy: public
+browser: false
+
+args:
+  limit:
+    type: int
+    default: 10
+    description: Number of games
+
+pipeline:
+  - fetch:
+      url: https://store.steampowered.com/api/featuredcategories/
+
+  - select: top_sellers.items
+
+  - map:
+      rank: ${{ index + 1 }}
+      name: ${{ item.name }}
+      price: ${{ item.final_price }}
+      discount: ${{ item.discount_percent }}
+      url: https://store.steampowered.com/app/${{ item.id }}
+
+  - limit: ${{ args.limit }}
+
+columns: [rank, name, price, discount, url]

package/dist/clis/twitter/accept.js

@@ -8,14 +8,14 @@ cli({
     browser: true,
     timeoutSeconds: 600, // 10 min — batch operation iterating many conversations
     args: [
-        { name: 'keyword', type: 'string', required: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
+        { name: 'query', type: 'string', required: true, positional: true, help: 'Keywords to match (comma-separated for OR, e.g. "群,微信")' },
         { name: 'max', type: 'int', required: false, default: 20, help: 'Maximum number of requests to accept (default: 20)' },
     ],
     columns: ['index', 'status', 'user', 'message'],
     func: async (page, kwargs) => {
         if (!page)
             throw new Error('Requires browser');
-        const keywords = kwargs.keyword.split(',').map((k) => k.trim()).filter(Boolean);
+        const keywords = kwargs.query.split(',').map((k) => k.trim()).filter(Boolean);
         const maxAccepts = kwargs.max ?? 20;
         const results = [];
         let acceptCount = 0;

package/dist/clis/twitter/article.js

@@ -7,12 +7,12 @@ cli({
     strategy: Strategy.COOKIE,
     browser: true,
     args: [
-        { name: 'tweet_id', type: 'string', positional: true, required: true, help: 'Tweet ID or URL containing the article' },
+        { name: 'tweet-id', type: 'string', positional: true, required: true, help: 'Tweet ID or URL containing the article' },
     ],
     columns: ['title', 'author', 'content', 'url'],
     func: async (page, kwargs) => {
         // Extract tweet ID from URL if needed
-        let tweetId = kwargs.tweet_id;
+        let tweetId = kwargs['tweet-id'];
         const urlMatch = tweetId.match(/\/(?:status|article)\/(\d+)/);
         if (urlMatch)
             tweetId = urlMatch[1];

package/dist/clis/twitter/block.d.ts

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

package/dist/clis/twitter/block.js

@@ -0,0 +1,88 @@
+import { cli, Strategy } from '../../registry.js';
+cli({
+    site: 'twitter',
+    name: 'block',
+    description: 'Block 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;
+
+            // Check if already blocked (profile shows "Blocked" / unblock button)
+            while (attempts < 20) {
+                const blockedIndicator = document.querySelector('[data-testid$="-unblock"]');
+                if (blockedIndicator) {
+                    return { ok: true, message: 'Already blocking @${username}.' };
+                }
+
+                const moreBtn = document.querySelector('[data-testid="userActions"]');
+                if (moreBtn) break;
+
+                await new Promise(r => setTimeout(r, 500));
+                attempts++;
+            }
+
+            const moreBtn = document.querySelector('[data-testid="userActions"]');
+            if (!moreBtn) {
+                return { ok: false, message: 'Could not find user actions menu. Are you logged in?' };
+            }
+
+            // Open the more actions menu
+            moreBtn.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Find the Block menu item
+            const menuItems = document.querySelectorAll('[role="menuitem"]');
+            let blockItem = null;
+            for (const item of menuItems) {
+                if (item.textContent && item.textContent.includes('Block')) {
+                    blockItem = item;
+                    break;
+                }
+            }
+
+            if (!blockItem) {
+                return { ok: false, message: 'Could not find Block option in menu.' };
+            }
+
+            blockItem.click();
+            await new Promise(r => setTimeout(r, 1000));
+
+            // Confirm the block in the dialog
+            const confirmBtn = document.querySelector('[data-testid="confirmationSheetConfirm"]');
+            if (confirmBtn) {
+                confirmBtn.click();
+                await new Promise(r => setTimeout(r, 1500));
+            }
+
+            // Verify
+            const verify = document.querySelector('[data-testid$="-unblock"]');
+            if (verify) {
+                return { ok: true, message: 'Successfully blocked @${username}.' };
+            } else {
+                return { ok: false, message: 'Block 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/twitter/delete.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 delete' },
+        { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to delete' },
     ],
     columns: ['status', 'message'],
     func: async (page, kwargs) => {

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', 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/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'],

package/dist/clis/weread/notes.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', 'review', 'createTime'],

package/dist/clis/weread/search.js

@@ -8,7 +8,7 @@ cli({
     strategy: Strategy.PUBLIC,
     browser: false,
     args: [
-        { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+        { name: 'query', positional: true, required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
     ],
     columns: ['rank', 'title', 'author', 'bookId'],

package/dist/clis/wikipedia/search.js

@@ -8,7 +8,7 @@ cli({
     strategy: Strategy.PUBLIC,
     browser: false,
     args: [
-        { name: 'keyword', positional: true, required: true, help: 'Search keyword' },
+        { name: 'query', positional: true, required: true, help: 'Search keyword' },
         { name: 'limit', type: 'int', default: 10, help: 'Max results' },
         { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
     ],

package/dist/clis/xiaohongshu/creator-note-detail.d.ts

@@ -16,6 +16,20 @@ type CreatorNoteDetailRow = {
     extra: string;
 };
 export type { CreatorNoteDetailRow };
+type CreatorNoteDetailDomMetric = {
+    label: string;
+    value: string;
+    extra: string;
+};
+type CreatorNoteDetailDomSection = {
+    title: string;
+    metrics: CreatorNoteDetailDomMetric[];
+};
+type CreatorNoteDetailDomData = {
+    title: string;
+    infoText: string;
+    sections: CreatorNoteDetailDomSection[];
+};
 type AudienceSourceItem = {
     title?: string;
     value_with_double?: number;
@@ -64,6 +78,7 @@ type NoteDetailApiPayload = {
     };
 };
 export declare function parseCreatorNoteDetailText(bodyText: string, noteId: string): CreatorNoteDetailRow[];
+export declare function parseCreatorNoteDetailDomData(dom: CreatorNoteDetailDomData | null | undefined, noteId: string): CreatorNoteDetailRow[];
 export declare function appendAudienceRows(rows: CreatorNoteDetailRow[], payload?: NoteDetailApiPayload): CreatorNoteDetailRow[];
 export declare function appendTrendRows(rows: CreatorNoteDetailRow[], payload?: NoteDetailApiPayload): CreatorNoteDetailRow[];
 export declare function fetchCreatorNoteDetailRows(page: IPage, noteId: string): Promise<CreatorNoteDetailRow[]>;