@jackwener/opencli 1.4.0 → 1.4.1

package/dist/clis/youtube/channel.js

@@ -0,0 +1,150 @@
+/**
+ * YouTube channel — get channel info and recent videos via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+cli({
+    site: 'youtube',
+    name: 'channel',
+    description: 'Get YouTube channel info and recent videos',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Channel ID (UCxxxx) or handle (@name)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max recent videos (max 30)' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const channelId = String(kwargs.id);
+        const limit = Math.min(kwargs.limit || 10, 30);
+        await page.goto('https://www.youtube.com');
+        await page.wait(2);
+        const data = await page.evaluate(`
+      (async () => {
+        const channelId = ${JSON.stringify(channelId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Resolve handle to browseId if needed
+        let browseId = channelId;
+        if (channelId.startsWith('@')) {
+          const resolveResp = await fetch('/youtubei/v1/navigation/resolve_url?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, url: 'https://www.youtube.com/' + channelId})
+          });
+          if (resolveResp.ok) {
+            const resolveData = await resolveResp.json();
+            browseId = resolveData.endpoint?.browseEndpoint?.browseId || channelId;
+          }
+        }
+
+        // Fetch channel data
+        const resp = await fetch('/youtubei/v1/browse?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, browseId})
+        });
+        if (!resp.ok) return {error: 'Channel API returned HTTP ' + resp.status};
+        const data = await resp.json();
+
+        // Channel metadata
+        const metadata = data.metadata?.channelMetadataRenderer || {};
+        const header = data.header?.pageHeaderRenderer || data.header?.c4TabbedHeaderRenderer || {};
+
+        // Subscriber count from header
+        let subscriberCount = '';
+        try {
+          const rows = header.content?.pageHeaderViewModel?.metadata?.contentMetadataViewModel?.metadataRows || [];
+          for (const row of rows) {
+            for (const part of (row.metadataParts || [])) {
+              const text = part.text?.content || '';
+              if (text.includes('subscriber')) subscriberCount = text;
+            }
+          }
+        } catch {}
+        // Fallback for old c4TabbedHeaderRenderer format
+        if (!subscriberCount && header.subscriberCountText?.simpleText) {
+          subscriberCount = header.subscriberCountText.simpleText;
+        }
+
+        // Extract recent videos from Home tab
+        const tabs = data.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        const homeTab = tabs.find(t => t.tabRenderer?.selected);
+        const recentVideos = [];
+
+        if (homeTab) {
+          const sections = homeTab.tabRenderer?.content?.sectionListRenderer?.contents || [];
+          for (const section of sections) {
+            for (const shelf of (section.itemSectionRenderer?.contents || [])) {
+              for (const item of (shelf.shelfRenderer?.content?.horizontalListRenderer?.items || [])) {
+                // New lockupViewModel format
+                const lvm = item.lockupViewModel;
+                if (lvm && lvm.contentType === 'LOCKUP_CONTENT_TYPE_VIDEO' && recentVideos.length < limit) {
+                  const meta = lvm.metadata?.lockupMetadataViewModel;
+                  const rows = meta?.metadata?.contentMetadataViewModel?.metadataRows || [];
+                  const viewsAndTime = (rows[0]?.metadataParts || []).map(p => p.text?.content).filter(Boolean).join(' | ');
+                  let duration = '';
+                  for (const ov of (lvm.contentImage?.thumbnailViewModel?.overlays || [])) {
+                    for (const b of (ov.thumbnailBottomOverlayViewModel?.badges || [])) {
+                      if (b.thumbnailBadgeViewModel?.text) duration = b.thumbnailBadgeViewModel.text;
+                    }
+                  }
+                  recentVideos.push({
+                    title: meta?.title?.content || '',
+                    duration,
+                    views: viewsAndTime,
+                    url: 'https://www.youtube.com/watch?v=' + lvm.contentId,
+                  });
+                }
+                // Legacy gridVideoRenderer format
+                if (item.gridVideoRenderer && recentVideos.length < limit) {
+                  const v = item.gridVideoRenderer;
+                  recentVideos.push({
+                    title: v.title?.runs?.[0]?.text || v.title?.simpleText || '',
+                    duration: v.thumbnailOverlays?.[0]?.thumbnailOverlayTimeStatusRenderer?.text?.simpleText || '',
+                    views: (v.shortViewCountText?.simpleText || '') + (v.publishedTimeText?.simpleText ? ' | ' + v.publishedTimeText.simpleText : ''),
+                    url: 'https://www.youtube.com/watch?v=' + v.videoId,
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        return {
+          name: metadata.title || '',
+          channelId: metadata.externalId || browseId,
+          handle: metadata.vanityChannelUrl?.split('/').pop() || '',
+          description: (metadata.description || '').substring(0, 500),
+          subscribers: subscriberCount,
+          url: metadata.channelUrl || 'https://www.youtube.com/channel/' + browseId,
+          keywords: metadata.keywords || '',
+          recentVideos,
+        };
+      })()
+    `);
+        if (!data || typeof data !== 'object')
+            throw new CommandExecutionError('Failed to fetch channel data');
+        if (data.error)
+            throw new CommandExecutionError(String(data.error));
+        const result = data;
+        const videos = result.recentVideos;
+        delete result.recentVideos;
+        // Channel info as field/value pairs + recent videos as table
+        const rows = Object.entries(result).map(([field, value]) => ({
+            field,
+            value: String(value),
+        }));
+        if (videos && videos.length > 0) {
+            rows.push({ field: '---', value: '--- Recent Videos ---' });
+            for (const v of videos) {
+                rows.push({ field: v.title, value: `${v.duration} | ${v.views} | ${v.url}` });
+            }
+        }
+        return rows;
+    },
+});

package/dist/clis/youtube/comments.d.ts

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

package/dist/clis/youtube/comments.js

@@ -0,0 +1,95 @@
+/**
+ * YouTube comments — get video comments via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+import { parseVideoId } from './utils.js';
+cli({
+    site: 'youtube',
+    name: 'comments',
+    description: 'Get YouTube video comments',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'url', required: true, positional: true, help: 'YouTube video URL or video ID' },
+        { name: 'limit', type: 'int', default: 20, help: 'Max comments (max 100)' },
+    ],
+    columns: ['rank', 'author', 'text', 'likes', 'replies', 'time'],
+    func: async (page, kwargs) => {
+        const videoId = parseVideoId(kwargs.url);
+        const limit = Math.min(kwargs.limit || 20, 100);
+        await page.goto(`https://www.youtube.com/watch?v=${videoId}`);
+        await page.wait(3);
+        const data = await page.evaluate(`
+      (async () => {
+        const videoId = ${JSON.stringify(videoId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Step 1: Get comment continuation token
+        let continuationToken = null;
+
+        // Try from current page ytInitialData
+        if (window.ytInitialData) {
+          const results = window.ytInitialData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        // Fallback: fetch via next API
+        if (!continuationToken) {
+          const nextResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, videoId})
+          });
+          if (!nextResp.ok) return {error: 'Failed to get video data: HTTP ' + nextResp.status};
+          const nextData = await nextResp.json();
+          const results = nextData.contents?.twoColumnWatchNextResults?.results?.results?.contents || [];
+          const commentSection = results.find(i => i.itemSectionRenderer?.targetId === 'comments-section');
+          continuationToken = commentSection?.itemSectionRenderer?.contents?.[0]?.continuationItemRenderer?.continuationEndpoint?.continuationCommand?.token;
+        }
+
+        if (!continuationToken) return {error: 'No comment section found — comments may be disabled'};
+
+        // Step 2: Fetch comments
+        const commentResp = await fetch('/youtubei/v1/next?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, continuation: continuationToken})
+        });
+        if (!commentResp.ok) return {error: 'Failed to fetch comments: HTTP ' + commentResp.status};
+        const commentData = await commentResp.json();
+
+        // Parse from frameworkUpdates (new ViewModel format)
+        const mutations = commentData.frameworkUpdates?.entityBatchUpdate?.mutations || [];
+        const commentEntities = mutations.filter(m => m.payload?.commentEntityPayload);
+
+        return commentEntities.slice(0, limit).map((m, i) => {
+          const p = m.payload.commentEntityPayload;
+          const props = p.properties || {};
+          const author = p.author || {};
+          const toolbar = p.toolbar || {};
+          return {
+            rank: i + 1,
+            author: author.displayName || '',
+            text: (props.content?.content || '').substring(0, 300),
+            likes: toolbar.likeCountNotliked || '0',
+            replies: toolbar.replyCount || '0',
+            time: props.publishedTime || '',
+          };
+        });
+      })()
+    `);
+        if (!Array.isArray(data)) {
+            const errMsg = data && typeof data === 'object' ? String(data.error || '') : '';
+            if (errMsg)
+                throw new CommandExecutionError(errMsg);
+            return [];
+        }
+        return data;
+    },
+});

package/dist/clis/youtube/search.js

@@ -1,6 +1,5 @@
 /**
  * YouTube search — innertube API via browser session.
- * Source: bb-sites/youtube/search.js
  */
 import { cli, Strategy } from '../../registry.js';
 cli({

package/dist/clis/zhihu/search.yaml

@@ -52,7 +52,8 @@ pipeline:
       type: ${{ item.type }}
       author: ${{ item.author }}
       votes: ${{ item.votes }}
+      url: ${{ item.url }}
 
   - limit: ${{ args.limit }}
 
-columns: [rank, title, type, author, votes]
+columns: [rank, title, type, author, votes, url]

package/dist/external-clis.yaml

@@ -14,14 +14,6 @@
   install:
     mac: "brew install --cask obsidian"
 
-- name: readwise
-  binary: readwise
-  description: "Readwise & Reader CLI — highlights, annotations, reading list"
-  homepage: "https://github.com/readwiseio/readwise-cli"
-  tags: [reading, highlights]
-  install:
-    default: "npm install -g @readwiseio/readwise-cli"
-
 - name: docker
   binary: docker
   description: "Docker command-line interface"
@@ -29,12 +21,3 @@
   tags: [docker, containers, devops]
   install:
     mac: "brew install --cask docker"
-
-- name: gws
-  binary: gws
-  description: "Google Workspace CLI — Docs, Sheets, Drive, Gmail, Calendar"
-  homepage: "https://github.com/nicholasgasior/gws"
-  tags: [google, docs, sheets, drive, workspace]
-  install:
-    mac: "brew install gws"
-    default: "npm install -g @nicholasgasior/gws"

package/dist/weread-search-regression.test.d.ts

@@ -0,0 +1 @@
+import './clis/weread/search.js';

package/dist/weread-search-regression.test.js

@@ -0,0 +1,39 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from './registry.js';
+import './clis/weread/search.js';
+describe('weread/search regression', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses the query argument for the search API and returns urls', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: 'Deep Work',
+                            author: 'Cal Newport',
+                            bookId: 'abc123',
+                        },
+                    },
+                ],
+            }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(String(fetchMock.mock.calls[0][0])).toContain('keyword=deep+work');
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: 'Deep Work',
+                author: 'Cal Newport',
+                bookId: 'abc123',
+                url: 'https://weread.qq.com/web/bookDetail/abc123',
+            },
+        ]);
+    });
+});

package/docs/.vitepress/config.mts

@@ -74,6 +74,16 @@ export default defineConfig({
                 { text: 'Sina Blog', link: '/adapters/browser/sinablog' },
                 { text: 'Substack', link: '/adapters/browser/substack' },
                 { text: 'Pixiv', link: '/adapters/browser/pixiv' },
+                { text: 'Douban', link: '/adapters/browser/douban' },
+                { text: 'Doubao', link: '/adapters/browser/doubao' },
+                { text: 'Facebook', link: '/adapters/browser/facebook' },
+                { text: 'Google', link: '/adapters/browser/google' },
+                { text: 'Instagram', link: '/adapters/browser/instagram' },
+                { text: 'JD.com', link: '/adapters/browser/jd' },
+                { text: 'Medium', link: '/adapters/browser/medium' },
+                { text: 'TikTok', link: '/adapters/browser/tiktok' },
+                { text: 'Web (Generic)', link: '/adapters/browser/web' },
+                { text: 'Weixin', link: '/adapters/browser/weixin' },
               ],
             },
             {
@@ -93,6 +103,8 @@ export default defineConfig({
                 { text: 'Sina Finance', link: '/adapters/browser/sinafinance' },
                 { text: 'Stack Overflow', link: '/adapters/browser/stackoverflow' },
                 { text: 'Wikipedia', link: '/adapters/browser/wikipedia' },
+                { text: 'Lobsters', link: '/adapters/browser/lobsters' },
+                { text: 'Steam', link: '/adapters/browser/steam' },
               ],
             },
             {
@@ -106,6 +118,7 @@ export default defineConfig({
                 { text: 'ChatWise', link: '/adapters/desktop/chatwise' },
                 { text: 'Notion', link: '/adapters/desktop/notion' },
                 { text: 'Discord', link: '/adapters/desktop/discord' },
+                { text: 'Doubao App', link: '/adapters/desktop/doubao-app' },
               ],
             },
           ],

package/docs/adapters/browser/douyin.md

@@ -0,0 +1,75 @@
+# Douyin (抖音创作者中心)
+
+**Mode**: 🔐 Browser · **Domain**: `creator.douyin.com`
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `opencli douyin profile` | 获取账号信息 |
+| `opencli douyin videos` | 获取作品列表 |
+| `opencli douyin drafts` | 获取草稿列表 |
+| `opencli douyin draft` | 上传视频并保存为草稿 |
+| `opencli douyin publish` | 定时发布视频到抖音 |
+| `opencli douyin update` | 更新视频信息 |
+| `opencli douyin delete` | 删除作品 |
+| `opencli douyin stats` | 查询作品数据分析 |
+| `opencli douyin collections` | 获取合集列表 |
+| `opencli douyin activities` | 获取官方活动列表 |
+| `opencli douyin location` | 搜索发布可用的地理位置 |
+| `opencli douyin hashtag search` | 按关键词搜索话题 |
+| `opencli douyin hashtag suggest` | 基于封面 URI 推荐话题 |
+| `opencli douyin hashtag hot` | 获取热点词 |
+
+## Usage Examples
+
+```bash
+# 账号与作品
+opencli douyin profile
+opencli douyin videos --limit 10
+opencli douyin videos --status scheduled
+opencli douyin drafts
+
+# 发布前辅助信息
+opencli douyin collections
+opencli douyin activities
+opencli douyin location "东京塔"
+opencli douyin hashtag search "春游"
+opencli douyin hashtag hot --limit 10
+
+# 保存草稿
+opencli douyin draft ./video.mp4 \
+  --title "春游 vlog" \
+  --caption "#春游 先存草稿"
+
+# 定时发布
+opencli douyin publish ./video.mp4 \
+  --title "春游 vlog" \
+  --caption "#春游 今天去看樱花" \
+  --schedule "2026-04-08T12:00:00+09:00"
+
+# 也支持 Unix 秒字符串
+opencli douyin publish ./video.mp4 \
+  --title "春游 vlog" \
+  --schedule 1775617200
+
+# 更新与删除
+opencli douyin update 1234567890 --caption "更新后的文案"
+opencli douyin update 1234567890 --reschedule "2026-04-09T20:00:00+09:00"
+opencli douyin delete 1234567890
+
+# JSON 输出
+opencli douyin profile -f json
+```
+
+## Prerequisites
+
+- Chrome running and **logged into** `creator.douyin.com`
+- The logged-in account must have access to Douyin Creator Center publishing features
+- [Browser Bridge extension](/guide/browser-bridge) installed
+
+## Notes
+
+- `publish` requires `--schedule` to be at least 2 hours later and no more than 14 days later
+- `draft` and `publish` upload the video through Douyin/ByteDance browser-authenticated APIs, so cookies in the active browser session must be valid
+- `hashtag suggest` expects a valid `cover`/`cover_uri` value produced during the publish pipeline; for normal manual use, `hashtag search` and `hashtag hot` are usually more convenient

package/docs/adapters/browser/twitter.md

@@ -37,6 +37,12 @@
 # Quick start
 opencli twitter trending --limit 5
 
+# Search top tweets (default)
+opencli twitter search "react 19"
+
+# Search latest/live tweets
+opencli twitter search "react 19" --filter live
+
 # JSON output
 opencli twitter trending -f json
 

package/docs/adapters/index.md

@@ -11,7 +11,7 @@ Run `opencli list` for the live registry.
 | **[bilibili](/adapters/browser/bilibili)** | `hot` `search` `me` `favorite` `history` `feed` `subtitle` `dynamic` `ranking` `following` `user-videos` `download` | 🔐 Browser |
 | **[zhihu](/adapters/browser/zhihu)** | `hot` `search` `question` `download` | 🔐 Browser |
 | **[xiaohongshu](/adapters/browser/xiaohongshu)** | `search` `notifications` `feed` `user` `download` `publish` `creator-notes` `creator-note-detail` `creator-notes-summary` `creator-profile` `creator-stats` | 🔐 Browser |
-| **[xueqiu](/adapters/browser/xueqiu)** | `feed` `hot-stock` `hot` `search` `stock` `watchlist` `earnings-date` | 🔐 Browser |
+| **[xueqiu](/adapters/browser/xueqiu)** | `feed` `hot-stock` `hot` `search` `stock` `watchlist` `earnings-date` `fund-holdings` `fund-snapshot` | 🔐 Browser |
 | **[youtube](/adapters/browser/youtube)** | `search` `video` `transcript` | 🔐 Browser |
 | **[v2ex](/adapters/browser/v2ex)** | `hot` `latest` `topic` `node` `user` `member` `replies` `nodes` `daily` `me` `notifications` | 🌐 / 🔐 |
 | **[bloomberg](/adapters/browser/bloomberg)** | `main` `markets` `economics` `industries` `tech` `politics` `businessweek` `opinions` `feeds` `news` | 🌐 / 🔐 |
@@ -38,6 +38,10 @@ Run `opencli list` for the live registry.
 | **[substack](/adapters/browser/substack)** | `feed` `search` `publication` | 🔐 Browser |
 | **[pixiv](/adapters/browser/pixiv)** | `ranking` `search` `user` `illusts` `detail` `download` | 🔐 Browser |
 | **[tiktok](/adapters/browser/tiktok)** | `explore` `search` `profile` `user` `following` `follow` `unfollow` `like` `unlike` `comment` `save` `unsave` `live` `notifications` `friends` | 🔐 Browser |
+| **[google](/adapters/browser/google)** | `news` `search` `suggest` `trends` | 🌐 / 🔐 |
+| **[jd](/adapters/browser/jd)** | `item` | 🔐 Browser |
+| **[web](/adapters/browser/web)** | `read` | 🔐 Browser |
+| **[weixin](/adapters/browser/weixin)** | `download` | 🔐 Browser |
 
 ## Public API Adapters
 
@@ -57,6 +61,7 @@ Run `opencli list` for the live registry.
 | **[stackoverflow](/adapters/browser/stackoverflow)** | `hot` `search` `bounties` `unanswered` | 🌐 Public |
 | **[wikipedia](/adapters/browser/wikipedia)** | `search` `summary` `random` `trending` | 🌐 Public |
 | **[lobsters](/adapters/browser/lobsters)** | `hot` `newest` `active` `tag` | 🌐 Public |
+| **[steam](/adapters/browser/steam)** | `top-sellers` | 🌐 Public |
 
 ## Desktop Adapters