@jackwener/opencli 1.0.6 → 1.1.1

package/src/clis/twitter/block.ts

@@ -0,0 +1,92 @@
+import { cli, Strategy } from '../../registry.js';
+import type { IPage } from '../../types.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: 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;
+
+            // 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/src/clis/twitter/delete.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 delete' },
+    { name: 'url', type: 'string', required: true, positional: true, help: 'The URL of the tweet to delete' },
   ],
   columns: ['status', 'message'],
   func: async (page: IPage | null, kwargs: any) => {

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', 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/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) => {

package/src/clis/weread/highlights.ts

@@ -9,7 +9,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/src/clis/weread/notes.ts

@@ -9,7 +9,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/src/clis/weread/search.ts

@@ -9,7 +9,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/src/clis/wikipedia/search.ts

@@ -0,0 +1,32 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { wikiFetch } from './utils.js';
+
+interface WikiSearchResult { title: string; snippet: string; }
+
+cli({
+  site: 'wikipedia',
+  name: 'search',
+  description: 'Search Wikipedia articles',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { 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)' },
+  ],
+  columns: ['title', 'snippet', 'url'],
+  func: async (_page, args) => {
+    const limit = Math.max(1, Math.min(Number(args.limit), 50));
+    const lang = args.lang || 'en';
+    const q = encodeURIComponent(args.keyword);
+    const data = await wikiFetch(lang, `/w/api.php?action=query&list=search&srsearch=${q}&srlimit=${limit}&format=json&utf8=1`) as { query?: { search?: WikiSearchResult[] } };
+    const results = data?.query?.search;
+    if (!results?.length) throw new CliError('NOT_FOUND', 'No articles found', 'Try a different keyword');
+    return results.map((r) => ({
+      title: r.title,
+      snippet: r.snippet.replace(/<[^>]+>/g, '').slice(0, 120),
+      url: `https://${lang}.wikipedia.org/wiki/${encodeURIComponent(r.title.replace(/ /g, '_'))}`,
+    }));
+  },
+});

package/src/clis/wikipedia/summary.ts

@@ -0,0 +1,28 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { wikiFetch } from './utils.js';
+
+cli({
+  site: 'wikipedia',
+  name: 'summary',
+  description: 'Get Wikipedia article summary',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'title', positional: true, required: true, help: 'Article title (e.g. "Transformer (machine learning model)")' },
+    { name: 'lang', default: 'en', help: 'Language code (e.g. en, zh, ja)' },
+  ],
+  columns: ['title', 'description', 'extract', 'url'],
+  func: async (_page, args) => {
+    const lang = args.lang || 'en';
+    const title = encodeURIComponent(args.title.replace(/ /g, '_'));
+    const data = await wikiFetch(lang, `/api/rest_v1/page/summary/${title}`) as { title?: string; description?: string; extract?: string; content_urls?: { desktop?: { page?: string } } };
+    if (!data?.title) throw new CliError('NOT_FOUND', `Article "${args.title}" not found`, 'Try searching first: opencli wikipedia search <keyword>');
+    return [{
+      title: data.title,
+      description: data.description ?? '-',
+      extract: (data.extract ?? '').slice(0, 300),
+      url: data.content_urls?.desktop?.page ?? `https://${lang}.wikipedia.org/wiki/${title}`,
+    }];
+  },
+});

package/src/clis/wikipedia/utils.ts

@@ -0,0 +1,20 @@
+/**
+ * Wikipedia adapter utilities.
+ *
+ * Uses the public MediaWiki REST API and Action API — no key required.
+ * REST API: https://en.wikipedia.org/api/rest_v1/
+ * Action API: https://en.wikipedia.org/w/api.php
+ */
+
+import { CliError } from '../../errors.js';
+
+export async function wikiFetch(lang: string, path: string): Promise<unknown> {
+  const url = `https://${lang}.wikipedia.org${path}`;
+  const resp = await fetch(url, {
+    headers: { 'User-Agent': 'opencli/1.0 (https://github.com/jackwener/opencli)' },
+  });
+  if (!resp.ok) {
+    throw new CliError('FETCH_ERROR', `Wikipedia API HTTP ${resp.status}`, `Check your title or search term`);
+  }
+  return resp.json();
+}