@jackwener/opencli 1.4.0 → 1.5.0

package/src/clis/xiaohongshu/publish.test.ts

@@ -0,0 +1,137 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { getRegistry } from '../../registry.js';
+import type { IPage } from '../../types.js';
+import './publish.js';
+
+function createPageMock(evaluateResults: any[]): IPage {
+  const evaluate = vi.fn();
+  for (const result of evaluateResults) {
+    evaluate.mockResolvedValueOnce(result);
+  }
+
+  return {
+    goto: vi.fn().mockResolvedValue(undefined),
+    evaluate,
+    snapshot: vi.fn().mockResolvedValue(undefined),
+    click: vi.fn().mockResolvedValue(undefined),
+    typeText: vi.fn().mockResolvedValue(undefined),
+    pressKey: vi.fn().mockResolvedValue(undefined),
+    scrollTo: vi.fn().mockResolvedValue(undefined),
+    getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+    wait: vi.fn().mockResolvedValue(undefined),
+    tabs: vi.fn().mockResolvedValue([]),
+    closeTab: vi.fn().mockResolvedValue(undefined),
+    newTab: vi.fn().mockResolvedValue(undefined),
+    selectTab: vi.fn().mockResolvedValue(undefined),
+    networkRequests: vi.fn().mockResolvedValue([]),
+    consoleMessages: vi.fn().mockResolvedValue([]),
+    scroll: vi.fn().mockResolvedValue(undefined),
+    autoScroll: vi.fn().mockResolvedValue(undefined),
+    installInterceptor: vi.fn().mockResolvedValue(undefined),
+    getInterceptedRequests: vi.fn().mockResolvedValue([]),
+    getCookies: vi.fn().mockResolvedValue([]),
+    screenshot: vi.fn().mockResolvedValue(''),
+  };
+}
+
+describe('xiaohongshu publish', () => {
+  it('selects the image-text tab and publishes successfully', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-xhs-publish-'));
+    const imagePath = path.join(tempDir, 'demo.jpg');
+    fs.writeFileSync(imagePath, Buffer.from([0xff, 0xd8, 0xff, 0xd9]));
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      { ok: true, count: 1 },
+      false,
+      { ok: true, sel: 'input[maxlength="20"]' },
+      { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+      true,
+      'https://creator.xiaohongshu.com/publish/success',
+      '发布成功',
+    ]);
+
+    const result = await cmd!.func!(page, {
+      title: 'DeepSeek别乱问',
+      content: '一篇真实一点的小红书正文',
+      images: imagePath,
+      topics: '',
+      draft: false,
+    });
+
+    const evaluateCalls = (page.evaluate as any).mock.calls.map((args: any[]) => String(args[0]));
+    expect(evaluateCalls.some((code: string) => code.includes("const targets = ['上传图文', '图文', '图片']"))).toBe(true);
+    expect(evaluateCalls.some((code: string) => code.includes("No image file input found on page"))).toBe(true);
+    expect(result).toEqual([
+      {
+        status: '✅ 发布成功',
+        detail: '"DeepSeek别乱问" · 1张图片 · 发布成功',
+      },
+    ]);
+  });
+
+  it('fails early with a clear error when still on the video page', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: false, visibleTexts: ['上传视频', '上传图文'] },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+    ]);
+
+    await expect(cmd!.func!(page, {
+      title: 'DeepSeek别乱问',
+      content: '一篇真实一点的小红书正文',
+      topics: '',
+      draft: false,
+    })).rejects.toThrow('Still on the video publish page after trying to select 图文');
+
+    expect(page.screenshot).toHaveBeenCalledWith({ path: '/tmp/xhs_publish_tab_debug.png' });
+  });
+
+  it('waits for the image-text surface to appear after clicking the tab', async () => {
+    const cmd = getRegistry().get('xiaohongshu/publish');
+    expect(cmd?.func).toBeTypeOf('function');
+
+    const page = createPageMock([
+      'https://creator.xiaohongshu.com/publish/publish?from=menu_left',
+      { ok: true, target: '上传图文', text: '上传图文' },
+      { hasTitleInput: false, hasImageInput: false, hasVideoSurface: true },
+      { hasTitleInput: true, hasImageInput: true, hasVideoSurface: false },
+      { ok: true, sel: 'input[maxlength="20"]' },
+      { ok: true, sel: '[contenteditable="true"][class*="content"]' },
+      true,
+      'https://creator.xiaohongshu.com/publish/success',
+      '发布成功',
+    ]);
+
+    const result = await cmd!.func!(page, {
+      title: '延迟切换也能过',
+      content: '图文页切换慢一点也继续等',
+      topics: '',
+      draft: false,
+    });
+
+    expect((page.wait as any).mock.calls).toContainEqual([{ time: 0.5 }]);
+    expect(result).toEqual([
+      {
+        status: '✅ 发布成功',
+        detail: '"延迟切换也能过" · 无图 · 发布成功',
+      },
+    ]);
+  });
+});

package/src/clis/xiaohongshu/publish.ts

@@ -63,14 +63,22 @@ async function injectImages(page: IPage, images: ImagePayload[]): Promise<{ ok:
     (async () => {
       const images = ${payload};
 
-      // Prefer image/* file inputs; fall back to the first available input.
+      // Only use image-capable file inputs. Do not fall back to a generic uploader,
+      // otherwise we can accidentally feed images into the video upload flow.
       const inputs = Array.from(document.querySelectorAll('input[type="file"]'));
       const input = inputs.find(el => {
         const accept = el.getAttribute('accept') || '';
-        return accept.includes('image') || accept.includes('.jpg') || accept.includes('.png');
-      }) || inputs[0];
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
 
-      if (!input) return { ok: false, count: 0, error: 'No file input found on page' };
+      if (!input) return { ok: false, count: 0, error: 'No image file input found on page' };
 
       const dt = new DataTransfer();
       for (const img of images) {
@@ -151,6 +159,111 @@ async function fillField(page: IPage, selectors: string[], text: string, fieldNa
   }
 }
 
+async function selectImageTextTab(
+  page: IPage,
+): Promise<{ ok: boolean; target?: string; text?: string; visibleTexts?: string[] }> {
+  const result = await page.evaluate(`
+    () => {
+      const isVisible = (el) => {
+        if (!el || el.offsetParent === null) return false;
+        const rect = el.getBoundingClientRect();
+        return rect.width > 0 && rect.height > 0;
+      };
+
+      const normalize = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+      const selector = 'button, [role="tab"], [role="button"], a, label, div, span, li';
+      const nodes = Array.from(document.querySelectorAll(selector));
+      const targets = ['上传图文', '图文', '图片'];
+
+      for (const target of targets) {
+        for (const node of nodes) {
+          if (!isVisible(node)) continue;
+          const text = normalize(node.innerText || node.textContent || '');
+          if (!text || text.includes('视频')) continue;
+          if (text === target || text.startsWith(target) || text.includes(target)) {
+            const clickable = node.closest('button, [role="tab"], [role="button"], a, label') || node;
+            clickable.click();
+            return { ok: true, target, text };
+          }
+        }
+      }
+
+      const visibleTexts = [];
+      for (const node of nodes) {
+        if (!isVisible(node)) continue;
+        const text = normalize(node.innerText || node.textContent || '');
+        if (!text || text.length > 20) continue;
+        visibleTexts.push(text);
+        if (visibleTexts.length >= 20) break;
+      }
+      return { ok: false, visibleTexts };
+    }
+  `);
+  if (result?.ok) {
+    await page.wait({ time: 1 });
+  }
+  return result;
+}
+
+async function inspectPublishSurface(
+  page: IPage,
+): Promise<{ hasTitleInput: boolean; hasImageInput: boolean; hasVideoSurface: boolean }> {
+  return page.evaluate(`
+    () => {
+      const text = (document.body?.innerText || '').replace(/\\s+/g, ' ').trim();
+      const hasTitleInput = !!Array.from(document.querySelectorAll('input, textarea')).find((el) => {
+        if (!el || el.offsetParent === null) return false;
+        const placeholder = (el.getAttribute('placeholder') || '').trim();
+        const cls = el.className ? String(el.className) : '';
+        const maxLength = Number(el.getAttribute('maxlength') || 0);
+        return (
+          placeholder.includes('标题') ||
+          /title/i.test(placeholder) ||
+          /title/i.test(cls) ||
+          maxLength === 20
+        );
+      });
+      const hasImageInput = !!Array.from(document.querySelectorAll('input[type="file"]')).find((el) => {
+        const accept = el.getAttribute('accept') || '';
+        return (
+          accept.includes('image') ||
+          accept.includes('.jpg') ||
+          accept.includes('.jpeg') ||
+          accept.includes('.png') ||
+          accept.includes('.gif') ||
+          accept.includes('.webp')
+        );
+      });
+      return {
+        hasTitleInput,
+        hasImageInput,
+        hasVideoSurface: text.includes('拖拽视频到此处点击上传') || text.includes('上传视频'),
+      };
+    }
+  `);
+}
+
+async function waitForImageTextSurface(
+  page: IPage,
+  maxWaitMs = 5_000,
+): Promise<{ hasTitleInput: boolean; hasImageInput: boolean; hasVideoSurface: boolean }> {
+  const pollMs = 500;
+  const maxAttempts = Math.max(1, Math.ceil(maxWaitMs / pollMs));
+  let surface = await inspectPublishSurface(page);
+
+  for (let i = 0; i < maxAttempts; i++) {
+    if (surface.hasTitleInput || surface.hasImageInput || !surface.hasVideoSurface) {
+      return surface;
+    }
+    if (i < maxAttempts - 1) {
+      await page.wait({ time: pollMs / 1_000 });
+      surface = await inspectPublishSurface(page);
+    }
+  }
+
+  return surface;
+}
+
 cli({
   site: 'xiaohongshu',
   name: 'publish',
@@ -204,20 +317,18 @@ cli({
     }
 
     // ── Step 2: Select 图文 (image+text) note type if tabs are present ─────────
-    const tabClicked: boolean = await page.evaluate(`
-      () => {
-        const allEls = document.querySelectorAll('[class*="tab"], [class*="note-type"], [class*="type-item"]');
-        for (const el of allEls) {
-          const text = el.innerText || el.textContent || '';
-          if ((text.includes('图文') || text.includes('图片')) && el.offsetParent !== null) {
-            el.click();
-            return true;
-          }
-        }
-        return false;
-      }
-    `);
-    if (tabClicked) await page.wait({ time: 1 });
+    const tabResult = await selectImageTextTab(page);
+    const surface = await waitForImageTextSurface(page, tabResult?.ok ? 5_000 : 2_000);
+    if (!surface.hasTitleInput && !surface.hasImageInput && surface.hasVideoSurface) {
+      await page.screenshot({ path: '/tmp/xhs_publish_tab_debug.png' });
+      const detail = tabResult?.ok
+        ? `clicked "${tabResult.text}"`
+        : `visible candidates: ${(tabResult?.visibleTexts || []).join(' | ') || 'none'}`;
+      throw new Error(
+        'Still on the video publish page after trying to select 图文. ' +
+        `Details: ${detail}. Debug screenshot: /tmp/xhs_publish_tab_debug.png`
+      );
+    }
 
     // ── Step 3: Upload images ──────────────────────────────────────────────────
     if (imageData.length > 0) {

package/src/clis/xueqiu/search.yaml

@@ -48,7 +48,8 @@ pipeline:
       exchange: ${{ item.exchange }}
       price: ${{ item.price }}
       changePercent: ${{ item.changePercent }}
+      url: ${{ item.url }}
       
   - limit: ${{ args.limit }}
 
-columns: [symbol, name, exchange, price, changePercent]
+columns: [symbol, name, exchange, price, changePercent, url]

package/src/clis/yahoo-finance/quote.ts

@@ -1,6 +1,5 @@
 /**
  * Yahoo Finance stock quote — multi-strategy API fallback.
- * Source: bb-sites/yahoo-finance/quote.js
  */
 import { cli, Strategy } from '../../registry.js';
 

package/src/clis/youtube/channel.ts

@@ -0,0 +1,155 @@
+/**
+ * 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 as Record<string, unknown>).error) throw new CommandExecutionError(String((data as Record<string, unknown>).error));
+
+    const result = data as Record<string, unknown>;
+    const videos = result.recentVideos as Array<Record<string, string>> | undefined;
+    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/src/clis/youtube/comments.ts

@@ -0,0 +1,97 @@
+/**
+ * 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 as Record<string, unknown>).error || '') : '';
+      if (errMsg) throw new CommandExecutionError(errMsg);
+      return [];
+    }
+    return data;
+  },
+});

package/src/clis/youtube/search.ts

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

package/src/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/src/commanderAdapter.test.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Command } from 'commander';
+import type { CliCommand } from './registry.js';
+
+const { mockExecuteCommand, mockRenderOutput } = vi.hoisted(() => ({
+  mockExecuteCommand: vi.fn(),
+  mockRenderOutput: vi.fn(),
+}));
+
+vi.mock('./execution.js', () => ({
+  executeCommand: mockExecuteCommand,
+}));
+
+vi.mock('./output.js', () => ({
+  render: mockRenderOutput,
+}));
+
+import { registerCommandToProgram } from './commanderAdapter.js';
+
+describe('commanderAdapter arg passing', () => {
+  const cmd: CliCommand = {
+    site: 'paperreview',
+    name: 'submit',
+    description: 'Submit a PDF',
+    browser: false,
+    args: [
+      { name: 'pdf', positional: true, required: true, help: 'Path to the paper PDF' },
+      { name: 'dry-run', type: 'bool', default: false, help: 'Validate only' },
+      { name: 'prepare-only', type: 'bool', default: false, help: 'Prepare only' },
+    ],
+    func: vi.fn(),
+  };
+
+  beforeEach(() => {
+    mockExecuteCommand.mockReset();
+    mockExecuteCommand.mockResolvedValue([]);
+    mockRenderOutput.mockReset();
+    delete process.env.OPENCLI_VERBOSE;
+    process.exitCode = undefined;
+  });
+
+  it('passes bool flag values through to executeCommand for coercion', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'false']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.pdf).toBe('./paper.pdf');
+    expect(kwargs).toHaveProperty('dry-run');
+  });
+
+  it('passes valueless bool flags as true to executeCommand', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--prepare-only']);
+
+    expect(mockExecuteCommand).toHaveBeenCalled();
+    const kwargs = mockExecuteCommand.mock.calls[0][1];
+    expect(kwargs.pdf).toBe('./paper.pdf');
+    expect(kwargs['prepare-only']).toBe(true);
+  });
+
+  it('rejects invalid bool values before calling executeCommand', async () => {
+    const program = new Command();
+    const siteCmd = program.command('paperreview');
+    registerCommandToProgram(siteCmd, cmd);
+
+    await program.parseAsync(['node', 'opencli', 'paperreview', 'submit', './paper.pdf', '--dry-run', 'maybe']);
+
+    // normalizeArgValue validates bools eagerly; executeCommand should not be reached
+    expect(mockExecuteCommand).not.toHaveBeenCalled();
+  });
+});