@jackwener/opencli 1.4.0 → 1.5.0

package/dist/clis/xiaohongshu/publish.js

@@ -57,14 +57,22 @@ async function injectImages(page, images) {
     (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) {
@@ -141,6 +149,99 @@ async function fillField(page, selectors, text, fieldName) {
         throw new Error(`Could not find ${fieldName} input. Debug screenshot: /tmp/xhs_publish_${fieldName}_debug.png`);
     }
 }
+async function selectImageTextTab(page) {
+    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) {
+    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, maxWaitMs = 5_000) {
+    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',
@@ -189,21 +290,16 @@ cli({
                 'Re-capture browser login via: opencli xiaohongshu creator-profile');
         }
         // ── Step 2: Select 图文 (image+text) note type if tabs are present ─────────
-        const tabClicked = 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;
-          }
+        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`);
         }
-        return false;
-      }
-    `);
-        if (tabClicked)
-            await page.wait({ time: 1 });
         // ── Step 3: Upload images ──────────────────────────────────────────────────
         if (imageData.length > 0) {
             const upload = await injectImages(page, imageData);

package/dist/clis/xiaohongshu/publish.test.d.ts

@@ -0,0 +1 @@
+import './publish.js';

package/dist/clis/xiaohongshu/publish.test.js

@@ -0,0 +1,119 @@
+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 './publish.js';
+function createPageMock(evaluateResults) {
+    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.mock.calls.map((args) => String(args[0]));
+        expect(evaluateCalls.some((code) => code.includes("const targets = ['上传图文', '图文', '图片']"))).toBe(true);
+        expect(evaluateCalls.some((code) => 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.mock.calls).toContainEqual([{ time: 0.5 }]);
+        expect(result).toEqual([
+            {
+                status: '✅ 发布成功',
+                detail: '"延迟切换也能过" · 无图 · 发布成功',
+            },
+        ]);
+    });
+});

package/dist/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/dist/clis/yahoo-finance/quote.js

@@ -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';
 cli({

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

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

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

@@ -11,6 +11,7 @@
  */
 import { Command } from 'commander';
 import { type CliCommand } from './registry.js';
+export declare function normalizeArgValue(argType: string | undefined, value: unknown, name: string): unknown;
 /**
  * Register a single CliCommand as a Commander subcommand.
  */