@jackwener/opencli 1.0.6 → 1.1.1

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.d.ts

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

package/dist/clis/wikipedia/search.js

@@ -0,0 +1,30 @@
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { wikiFetch } from './utils.js';
+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`);
+        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/dist/clis/wikipedia/summary.d.ts

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

package/dist/clis/wikipedia/summary.js

@@ -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}`);
+        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/dist/clis/wikipedia/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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
+ */
+export declare function wikiFetch(lang: string, path: string): Promise<unknown>;

package/dist/clis/wikipedia/utils.js

@@ -0,0 +1,18 @@
+/**
+ * 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, path) {
+    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();
+}

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

@@ -1,10 +1,84 @@
 /**
- * Xiaohongshu Creator Note Detail — per-note analytics breakdown.
+ * Xiaohongshu Creator Note Detail — per-note analytics from the creator detail page.
  *
- * Uses the creator.xiaohongshu.com internal API (cookie auth).
- * Returns total reads, engagement, likes, collects, comments, shares
- * for a specific note, split by channel (organic vs promoted vs video).
+ * The current creator center no longer serves stable single-note metrics from the legacy
+ * `/api/galaxy/creator/data/note_detail` endpoint. The real note detail page loads data
+ * through the newer `datacenter/note/*` API family, so this command navigates to the
+ * detail page and parses the rendered metrics that are backed by those APIs.
  *
  * Requires: logged into creator.xiaohongshu.com in Chrome.
  */
-export {};
+import type { IPage } from '../../types.js';
+type CreatorNoteDetailRow = {
+    section: string;
+    metric: string;
+    value: string;
+    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;
+    info?: {
+        imp_count?: number;
+        view_count?: number;
+        interaction_count?: number;
+    };
+};
+type AudiencePortraitItem = {
+    title?: string;
+    value?: number;
+};
+type NoteTrendPoint = {
+    date?: number;
+    count?: number;
+    count_with_double?: number;
+};
+type NoteTrendBucket = {
+    imp_list?: NoteTrendPoint[];
+    view_list?: NoteTrendPoint[];
+    view_time_list?: NoteTrendPoint[];
+    like_list?: NoteTrendPoint[];
+    comment_list?: NoteTrendPoint[];
+    collect_list?: NoteTrendPoint[];
+    share_list?: NoteTrendPoint[];
+    rise_fans_list?: NoteTrendPoint[];
+};
+type NoteDetailApiPayload = {
+    noteBase?: {
+        hour?: NoteTrendBucket;
+        day?: NoteTrendBucket;
+    };
+    audienceTrend?: {
+        no_data?: boolean;
+        no_data_tip_msg?: string;
+    };
+    audienceSource?: {
+        source?: AudienceSourceItem[];
+    };
+    audienceSourceDetail?: {
+        gender?: AudiencePortraitItem[];
+        age?: AudiencePortraitItem[];
+        city?: AudiencePortraitItem[];
+        interest?: AudiencePortraitItem[];
+    };
+};
+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[]>;