@jackwener/opencli 1.7.3 → 1.7.5

package/clis/uiverse/_shared.js

@@ -0,0 +1,368 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+export const UIVERSE_BASE_URL = 'https://uiverse.io';
+
+const ROUTE_DATA_KEY = 'routes/$username.$friendlyId';
+const CODE_DATA_KEY = 'routes/resource.post.code.$id';
+const EXPORT_TARGET_BUTTON_LABELS = ['React', 'Vue', 'Svelte', 'Lit'];
+
+function trimPathSegment(value) {
+  return String(value || '').trim().replace(/^\/+|\/+$/g, '');
+}
+
+export function parseComponentInput(input) {
+  const raw = String(input || '').trim();
+  if (!raw) {
+    throw new Error('Missing component input. Pass a full Uiverse URL or an author/slug identifier.');
+  }
+
+  let pathname = raw;
+  if (/^https?:\/\//i.test(raw)) {
+    const url = new URL(raw);
+    if (url.hostname !== 'uiverse.io' && url.hostname !== 'www.uiverse.io') {
+      throw new Error(`Unsupported non-Uiverse URL: ${raw}`);
+    }
+    pathname = url.pathname;
+  }
+
+  const cleaned = trimPathSegment(pathname);
+  const segments = cleaned.split('/').filter(Boolean);
+  if (segments.length !== 2) {
+    throw new Error(`Could not parse author/slug from input: ${raw}`);
+  }
+
+  const [username, slug] = segments;
+  if (!username || !slug) {
+    throw new Error(`Invalid component identifier: ${raw}. Expected author/slug.`);
+  }
+
+  return {
+    raw,
+    username,
+    slug,
+    url: `${UIVERSE_BASE_URL}/${username}/${slug}`,
+  };
+}
+
+async function fetchJsonInBrowser(page, url) {
+  const raw = await page.evaluate(`(async () => {
+    const url = ${JSON.stringify(url)};
+    const response = await fetch(url, {
+      credentials: 'include',
+      headers: {
+        accept: 'application/json, text/plain, */*',
+      },
+    });
+    const text = await response.text();
+    return JSON.stringify({
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      text,
+      url,
+    });
+  })()`);
+
+  const result = JSON.parse(raw);
+  if (!result?.ok) {
+    throw new Error(`Request failed: ${result?.status} ${result?.statusText} (${result?.url || url})`);
+  }
+
+  try {
+    return JSON.parse(result.text);
+  } catch {
+    throw new Error(`Response was not valid JSON: ${url}`);
+  }
+}
+
+export async function getPostDetails(page, input) {
+  const normalized = parseComponentInput(input);
+  await page.goto(normalized.url);
+
+  const raw = await page.evaluate(`(async () => {
+    const key = ${JSON.stringify(ROUTE_DATA_KEY)};
+    const loaderData = window.__remixContext?.state?.loaderData || {};
+    const routeData = loaderData[key];
+    return JSON.stringify({ routeData: routeData || null, keys: Object.keys(loaderData) });
+  })()`);
+
+  const parsed = JSON.parse(raw);
+  let routeData = parsed?.routeData;
+  if (!routeData?.post?.id) {
+    const routeUrl = `${normalized.url}?_data=${encodeURIComponent(ROUTE_DATA_KEY)}`;
+    routeData = await fetchJsonInBrowser(page, routeUrl);
+  }
+
+  if (!routeData?.post?.id) {
+    throw new Error(`Could not resolve post.id from the component page: ${normalized.url}`);
+  }
+
+  return {
+    ...normalized,
+    post: routeData.post,
+    routeData,
+  };
+}
+
+export async function getRawCode(page, postId) {
+  const codeUrl = `${UIVERSE_BASE_URL}/resource/post/code/${postId}?v=1&_data=${encodeURIComponent(CODE_DATA_KEY)}`;
+  const payload = await fetchJsonInBrowser(page, codeUrl);
+  if (typeof payload?.html !== 'string' || typeof payload?.css !== 'string') {
+    throw new Error(`Unexpected code payload shape: ${codeUrl}`);
+  }
+  return payload;
+}
+
+export function inferLanguage(target, post) {
+  if (target === 'react') return 'tsx';
+  if (target === 'vue') return 'vue';
+  if (target === 'html') return post?.isTailwind ? 'html+tailwind' : 'html';
+  if (target === 'css') return 'css';
+  return 'text';
+}
+
+export function getCodeLength(code) {
+  return String(code || '').length;
+}
+
+function normalizeExportTarget(target) {
+  return String(target || '').trim().toLowerCase() === 'vue' ? 'Vue' : 'React';
+}
+
+export async function extractExportCode(page, target = 'react') {
+  const targetLabel = normalizeExportTarget(target);
+  const raw = await page.evaluate(`(async () => {
+    const targetLabel = ${JSON.stringify(targetLabel)};
+    const exportButtonLabel = 'Export';
+    const exportTargetButtonLabels = ${JSON.stringify(EXPORT_TARGET_BUTTON_LABELS)};
+
+    const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+    const triggerClick = (element) => {
+      if (!element) return;
+      element.focus?.();
+      const pointer = { bubbles: true, cancelable: true, composed: true, view: window };
+      const mouse = { bubbles: true, cancelable: true, composed: true, view: window, button: 0, buttons: 1 };
+      element.dispatchEvent(new PointerEvent('pointerdown', pointer));
+      element.dispatchEvent(new MouseEvent('mousedown', mouse));
+      element.dispatchEvent(new PointerEvent('pointerup', pointer));
+      element.dispatchEvent(new MouseEvent('mouseup', mouse));
+      element.dispatchEvent(new MouseEvent('click', mouse));
+    };
+
+    const isCompleteExportCode = (code) => {
+      if (!code) return false;
+      if (targetLabel === 'Vue') {
+        return code.includes('<template>')
+          && code.includes('</template>')
+          && code.includes('<style')
+          && code.includes('</style>');
+      }
+      return code.includes('export default')
+        && (code.includes('styled-components') || code.includes('StyledWrapper') || code.includes('styled.'));
+    };
+
+    const readCode = () => {
+      const dialog = document.querySelector('[role="dialog"]');
+      if (!dialog) return null;
+      const heading = dialog.querySelector('h1,h2,h3,h4,h5,h6');
+      if (heading && (heading.textContent || '').trim() !== targetLabel) return null;
+      const textarea = dialog.querySelector('textarea');
+      if (textarea && textarea.value) return textarea.value;
+      return null;
+    };
+
+    const exportButton = [...document.querySelectorAll('button')].find((element) => (element.textContent || '').trim() === exportButtonLabel);
+    const currentTargetButton = [...document.querySelectorAll('button')].find((element) => {
+      const text = (element.textContent || '').trim();
+      return exportTargetButtonLabels.includes(text);
+    });
+
+    const existing = readCode();
+    if (!existing && (!exportButton || !currentTargetButton)) {
+      return JSON.stringify({ ok: false, error: 'Could not find the export controls on the page.' });
+    }
+
+    if (!existing) {
+      const currentLabel = (currentTargetButton.textContent || '').trim();
+      if (currentLabel === targetLabel) {
+        triggerClick(exportButton);
+      } else {
+        triggerClick(currentTargetButton);
+        let menuItem = null;
+        for (let index = 0; index < 20; index += 1) {
+          menuItem = [...document.querySelectorAll('[role="menuitem"]')].find((element) => (element.textContent || '').trim() === targetLabel);
+          if (menuItem) break;
+          await sleep(100);
+        }
+        if (!menuItem) {
+          return JSON.stringify({ ok: false, error: 'Could not find target in export menu: ' + targetLabel });
+        }
+        triggerClick(menuItem);
+      }
+    }
+
+    let longest = existing || '';
+    let longestLooksComplete = isCompleteExportCode(longest);
+    let stableCount = 0;
+
+    for (let index = 0; index < 40; index += 1) {
+      await sleep(200);
+      const code = readCode();
+      if (!code) continue;
+
+      if (code.length > longest.length) {
+        longest = code;
+        longestLooksComplete = isCompleteExportCode(code);
+        stableCount = 0;
+        continue;
+      }
+
+      if (code === longest) {
+        if (longestLooksComplete) {
+          stableCount += 1;
+          if (stableCount >= 2) {
+            return JSON.stringify({ ok: true, code: longest, length: longest.length });
+          }
+        } else {
+          stableCount = 0;
+        }
+      }
+    }
+
+    const dialog = document.querySelector('[role="dialog"]');
+    if (longest && longestLooksComplete) {
+      return JSON.stringify({ ok: true, code: longest, length: longest.length, fallback: true });
+    }
+
+    return JSON.stringify({
+      ok: false,
+      error: dialog
+        ? (targetLabel + ' dialog appeared, but the exported code never reached a stable complete state.')
+        : (targetLabel + ' export dialog did not appear after clicking the export controls.'),
+      dialogFound: Boolean(dialog),
+      dialogText: dialog ? (dialog.innerText || '').slice(0, 200) : null,
+      longestLength: longest.length,
+    });
+  })()`);
+
+  const data = JSON.parse(raw);
+  if (!data?.ok || typeof data.code !== 'string') {
+    throw new Error(data?.error || `Failed to extract ${targetLabel} export code.`);
+  }
+  return data.code;
+}
+
+export function parseHtmlRootSignature(html) {
+  const source = String(html || '').trim();
+  const match = source.match(/^<([a-zA-Z0-9-]+)([^>]*)>/);
+  if (!match) {
+    return { tag: null, id: null, classes: [] };
+  }
+
+  const [, tag, attrs] = match;
+  const idMatch = attrs.match(/\sid=["']([^"']+)["']/i);
+  const classMatch = attrs.match(/\sclass=["']([^"']+)["']/i);
+  const classes = classMatch ? classMatch[1].split(/\s+/).filter(Boolean) : [];
+  return {
+    tag: tag.toLowerCase(),
+    id: idMatch ? idMatch[1] : null,
+    classes,
+  };
+}
+
+export async function locatePreviewElement(page, html) {
+  const signature = parseHtmlRootSignature(html);
+  const raw = await page.evaluate(`(async () => {
+    const sig = ${JSON.stringify(signature)};
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    const fallbackTags = sig.tag ? [sig.tag] : ['label', 'button', 'a', 'div'];
+
+    const isVisible = (element) => {
+      if (!element || !(element instanceof Element)) return false;
+      if (element.closest('[role="dialog"]')) return false;
+      const style = window.getComputedStyle(element);
+      if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+      const rect = element.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0;
+    };
+
+    const scoreCandidate = (element, source) => {
+      const rect = element.getBoundingClientRect();
+      const centerX = rect.x + rect.width / 2;
+      const centerY = rect.y + rect.height / 2;
+      const area = rect.width * rect.height;
+      let score = 0;
+      if (sig.tag && element.tagName.toLowerCase() === sig.tag) score += 30;
+      if (sig.id && element.id === sig.id) score += 120;
+      if (sig.classes.length && sig.classes.every((className) => element.classList.contains(className))) score += 120;
+      if (centerX <= viewportWidth * 0.65) score += 40;
+      if (centerY <= viewportHeight * 0.6) score += 40;
+      if (area <= viewportWidth * viewportHeight * 0.2) score += 30;
+      if (area <= viewportWidth * viewportHeight * 0.05) score += 20;
+      return {
+        source,
+        tag: element.tagName.toLowerCase(),
+        className: element.className || '',
+        id: element.id || '',
+        score,
+        rect: {
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height,
+        },
+      };
+    };
+
+    const candidates = [];
+    const seen = new Set();
+    const collect = (element, source) => {
+      if (!isVisible(element)) return;
+      if (seen.has(element)) return;
+      seen.add(element);
+      candidates.push(scoreCandidate(element, source));
+    };
+
+    if (sig.id) collect(document.getElementById(sig.id), 'id');
+    if (sig.classes.length) collect(document.querySelector('.' + sig.classes.join('.')), 'classes');
+
+    for (const tagName of fallbackTags) {
+      const tagNodes = Array.from(document.querySelectorAll(tagName));
+      for (const node of tagNodes.slice(0, 200)) {
+        collect(node, 'tag:' + tagName);
+      }
+    }
+
+    candidates.sort((left, right) => {
+      if (right.score !== left.score) return right.score - left.score;
+      if (left.rect.y !== right.rect.y) return left.rect.y - right.rect.y;
+      if (left.rect.x !== right.rect.x) return left.rect.x - right.rect.x;
+      return (left.rect.width * left.rect.height) - (right.rect.width * right.rect.height);
+    });
+
+    return JSON.stringify({ signature: sig, best: candidates[0] || null, candidates: candidates.slice(0, 5) });
+  })()`);
+
+  const result = JSON.parse(raw);
+  if (!result?.best?.rect?.width || !result?.best?.rect?.height) {
+    throw new Error(`Could not locate a Uiverse preview element. Candidate data: ${JSON.stringify(result)}`);
+  }
+  return result;
+}
+
+export function getDefaultOutputPath({ username, slug, suffix, extension }) {
+  const safeUsername = trimPathSegment(username).replace(/[^a-zA-Z0-9-_]/g, '-');
+  const safeSlug = trimPathSegment(slug).replace(/[^a-zA-Z0-9-_]/g, '-');
+  return path.join(os.tmpdir(), `opencli-uiverse-${safeUsername}-${safeSlug}-${suffix}.${extension}`);
+}
+
+export async function saveBase64File(base64, outputPath) {
+  const resolved = path.resolve(outputPath);
+  await fs.mkdir(path.dirname(resolved), { recursive: true });
+  await fs.writeFile(resolved, Buffer.from(base64, 'base64'));
+  return resolved;
+}

package/clis/uiverse/_shared.test.js

@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import {
+  UIVERSE_BASE_URL,
+  parseComponentInput,
+  parseHtmlRootSignature,
+  inferLanguage,
+  getCodeLength,
+} from './_shared.js';
+
+describe('uiverse shared helpers', () => {
+  it('parses full URLs and author/slug identifiers', () => {
+    expect(parseComponentInput('Galahhad/strong-squid-82')).toEqual({
+      raw: 'Galahhad/strong-squid-82',
+      username: 'Galahhad',
+      slug: 'strong-squid-82',
+      url: `${UIVERSE_BASE_URL}/Galahhad/strong-squid-82`,
+    });
+
+    expect(parseComponentInput('https://uiverse.io/Galahhad/strong-squid-82')).toEqual({
+      raw: 'https://uiverse.io/Galahhad/strong-squid-82',
+      username: 'Galahhad',
+      slug: 'strong-squid-82',
+      url: `${UIVERSE_BASE_URL}/Galahhad/strong-squid-82`,
+    });
+  });
+
+  it('rejects unsupported hosts and malformed identifiers', () => {
+    expect(() => parseComponentInput('https://example.com/foo/bar')).toThrow('Unsupported non-Uiverse URL');
+    expect(() => parseComponentInput('only-author')).toThrow('Could not parse author/slug');
+    expect(() => parseComponentInput('a/b/c')).toThrow('Could not parse author/slug');
+  });
+
+  it('parses the HTML root signature', () => {
+    expect(parseHtmlRootSignature('<label id="x" class="theme-switch primary"></label>')).toEqual({
+      tag: 'label',
+      id: 'x',
+      classes: ['theme-switch', 'primary'],
+    });
+    expect(parseHtmlRootSignature('')).toEqual({ tag: null, id: null, classes: [] });
+  });
+
+  it('infers the language from target and metadata', () => {
+    expect(inferLanguage('react', {})).toBe('tsx');
+    expect(inferLanguage('vue', {})).toBe('vue');
+    expect(inferLanguage('html', { isTailwind: true })).toBe('html+tailwind');
+    expect(inferLanguage('css', {})).toBe('css');
+    expect(inferLanguage('unknown', {})).toBe('text');
+  });
+
+  it('returns the code length safely', () => {
+    expect(getCodeLength('abc')).toBe(3);
+    expect(getCodeLength('')).toBe(0);
+    expect(getCodeLength(null)).toBe(0);
+  });
+});

package/clis/uiverse/code.js

@@ -0,0 +1,47 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+  getPostDetails,
+  getRawCode,
+  extractExportCode,
+  inferLanguage,
+  getCodeLength,
+} from './_shared.js';
+
+cli({
+  site: 'uiverse',
+  name: 'code',
+  description: 'Export Uiverse component code (HTML, CSS, React, or Vue)',
+  domain: 'uiverse.io',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'input', type: 'str', required: true, positional: true, help: 'Uiverse URL or author/slug identifier' },
+    { name: 'target', type: 'str', required: true, choices: ['html', 'css', 'react', 'vue'], help: 'Code target to export' },
+  ],
+  columns: ['target', 'username', 'slug', 'language', 'length'],
+  func: async (page, kwargs) => {
+    const detail = await getPostDetails(page, kwargs.input);
+    const target = String(kwargs.target).toLowerCase();
+    let code = '';
+
+    if (target === 'react' || target === 'vue') {
+      code = await extractExportCode(page, target);
+    } else {
+      const payload = await getRawCode(page, detail.post.id);
+      code = target === 'html' ? payload.html : payload.css;
+    }
+
+    return {
+      target,
+      username: detail.username,
+      slug: detail.slug,
+      url: detail.url,
+      language: inferLanguage(target, detail.post),
+      length: getCodeLength(code),
+      code,
+      postId: detail.post.id,
+      type: detail.post.type,
+      isTailwind: Boolean(detail.post.isTailwind),
+    };
+  },
+});

package/clis/uiverse/preview.js

@@ -0,0 +1,71 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import {
+  getPostDetails,
+  getRawCode,
+  locatePreviewElement,
+  getDefaultOutputPath,
+  saveBase64File,
+} from './_shared.js';
+
+cli({
+  site: 'uiverse',
+  name: 'preview',
+  description: 'Capture a screenshot of the Uiverse preview element',
+  domain: 'uiverse.io',
+  strategy: Strategy.PUBLIC,
+  browser: true,
+  args: [
+    { name: 'input', type: 'str', required: true, positional: true, help: 'Uiverse URL or author/slug identifier' },
+    { name: 'output', type: 'str', required: false, help: 'Output image path (defaults to a temp file)' },
+    { name: 'padding', type: 'int', required: false, default: 8, help: 'Extra padding around the captured preview in pixels' },
+  ],
+  columns: ['username', 'slug', 'width', 'height', 'output'],
+  func: async (page, kwargs) => {
+    const detail = await getPostDetails(page, kwargs.input);
+    const payload = await getRawCode(page, detail.post.id);
+
+    const located = await locatePreviewElement(page, payload.html);
+    const rect = located.best.rect;
+    const padding = Math.max(0, Number(kwargs.padding ?? 8));
+    const clip = {
+      x: Math.max(0, rect.x - padding),
+      y: Math.max(0, rect.y - padding),
+      width: Math.max(1, rect.width + padding * 2),
+      height: Math.max(1, rect.height + padding * 2),
+      scale: 1,
+    };
+
+    const shot = await page.cdp('Page.captureScreenshot', {
+      format: 'png',
+      clip,
+      captureBeyondViewport: false,
+    });
+    const base64 = typeof shot === 'string' ? shot : shot?.data;
+    if (!base64) {
+      throw new Error('CDP screenshot failed: no image data was returned.');
+    }
+
+    const outputPath = kwargs.output || getDefaultOutputPath({
+      username: detail.username,
+      slug: detail.slug,
+      suffix: 'preview',
+      extension: 'png',
+    });
+    const savedPath = await saveBase64File(base64, outputPath);
+
+    return {
+      username: detail.username,
+      slug: detail.slug,
+      url: detail.url,
+      output: savedPath,
+      width: Math.round(clip.width),
+      height: Math.round(clip.height),
+      x: Math.round(clip.x),
+      y: Math.round(clip.y),
+      selectorSource: located.best.source,
+      matchedTag: located.best.tag,
+      matchedClassName: located.best.className,
+      postId: detail.post.id,
+    };
+  },
+});

package/clis/wanfang/search.js

@@ -0,0 +1,66 @@
+import { cli, Strategy } from '@jackwener/opencli/registry';
+import { clampInt, requireNonEmptyQuery } from '../_shared/common.js';
+
+cli({
+    site: 'wanfang',
+    name: 'search',
+    description: '万方数据论文搜索',
+    domain: 's.wanfangdata.com.cn',
+    strategy: Strategy.PUBLIC,
+    browser: true,
+    args: [
+        { name: 'query', positional: true, required: true, help: '搜索关键词' },
+        { name: 'limit', type: 'int', default: 10, help: '返回结果数量 (max 20)' },
+    ],
+    columns: ['rank', 'title', 'authors', 'source', 'year', 'type', 'cited', 'url'],
+    navigateBefore: false,
+    func: async (page, kwargs) => {
+        const limit = clampInt(kwargs.limit, 10, 1, 20);
+        const query = requireNonEmptyQuery(kwargs.query);
+        await page.goto(`https://s.wanfangdata.com.cn/paper?q=${encodeURIComponent(query)}`);
+        await page.wait(5);
+        const data = await page.evaluate(`
+      (async () => {
+        const normalize = v => (v || '').replace(/\\s+/g, ' ').trim();
+        for (let i = 0; i < 30; i++) {
+          if (document.querySelectorAll('span.title').length > 0) break;
+          await new Promise(r => setTimeout(r, 500));
+        }
+        const results = [];
+        for (const titleSpan of document.querySelectorAll('span.title')) {
+          const title = normalize(titleSpan.textContent);
+          if (!title || title.length < 3) continue;
+
+          let container = titleSpan.parentElement;
+          for (let i = 0; i < 6; i++) {
+            if (!container?.parentElement || container.parentElement.tagName === 'BODY') break;
+            if (container.querySelectorAll('span.title').length >= 1 && container.querySelectorAll('span.authors').length >= 1) break;
+            container = container.parentElement;
+          }
+          if (!container) continue;
+
+          const id = normalize(container.querySelector('span.title-id-hidden')?.textContent);
+          const url = id ? 'https://d.wanfangdata.com.cn/' + id : '';
+          const authors = Array.from(container.querySelectorAll('span.authors'))
+            .map((item) => normalize(item.textContent))
+            .filter(Boolean)
+            .join(', ')
+            .slice(0, 80);
+          const type = normalize(container.querySelector('span.essay-type')?.textContent);
+          const source = normalize(container.querySelector('span.periodical, span.source')?.textContent);
+
+          let year = normalize(container.querySelector('span.year, span.date')?.textContent);
+          if (!year) year = (container.textContent || '').match(/(19|20)\\d{2}/)?.[0] || '';
+
+          const citedText = normalize(container.querySelector('.stat-item.quote, [class*=\"quote\"]')?.textContent);
+          const cited = citedText.match(/(\\d+)/)?.[1] || '0';
+
+          results.push({ rank: results.length + 1, title, authors, source, year, type, cited, url });
+          if (results.length >= ${limit}) break;
+        }
+        return results;
+      })()
+    `);
+        return Array.isArray(data) ? data : [];
+    },
+});

package/clis/wanfang/search.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+
+describe('wanfang search command', () => {
+    const command = getRegistry().get('wanfang/search');
+
+    it('registers as a public browser command', () => {
+        expect(command).toBeDefined();
+        expect(command.site).toBe('wanfang');
+        expect(command.strategy).toBe('public');
+        expect(command.browser).toBe(true);
+    });
+
+    it('rejects empty queries before browser navigation', async () => {
+        const page = { goto: vi.fn() };
+        await expect(command.func(page, { query: '   ' })).rejects.toMatchObject({
+            name: 'ArgumentError',
+            code: 'ARGUMENT',
+        });
+        expect(page.goto).not.toHaveBeenCalled();
+    });
+});

package/clis/web/read.js

@@ -27,7 +27,7 @@ cli({
         { name: 'download-images', type: 'boolean', default: true, help: 'Download images locally' },
         { name: 'wait', type: 'int', default: 3, help: 'Seconds to wait after page load' },
     ],
-    columns: ['title', 'author', 'publish_time', 'status', 'size'],
+    columns: ['title', 'author', 'publish_time', 'status', 'size', 'saved'],
     func: async (page, kwargs) => {
         const url = kwargs.url;
         const waitSeconds = kwargs.wait ?? 3;

package/clis/weixin/download.js

@@ -179,12 +179,12 @@ cli({
         { name: 'output', default: './weixin-articles', help: 'Output directory' },
         { name: 'download-images', type: 'boolean', default: true, help: 'Download images locally' },
     ],
-    columns: ['title', 'author', 'publish_time', 'status', 'size'],
+    columns: ['title', 'author', 'publish_time', 'status', 'size', 'saved'],
     func: async (page, kwargs) => {
         const rawUrl = kwargs.url;
         const url = normalizeWechatUrl(rawUrl);
         if (!url.startsWith('https://mp.weixin.qq.com/')) {
-            return [{ title: 'Error', author: '-', publish_time: '-', status: 'invalid URL', size: '-' }];
+            return [{ title: 'Error', author: '-', publish_time: '-', status: 'invalid URL', size: '-', saved: '-' }];
         }
         // Navigate and wait for content to load
         await page.goto(url);
@@ -297,6 +297,7 @@ cli({
                     publish_time: '-',
                     status: 'failed — verification required in WeChat browser page',
                     size: '-',
+                    saved: '-',
                 }];
         }
         return downloadArticle({

package/clis/xiaohongshu/comments.js

@@ -22,7 +22,7 @@ cli({
     strategy: Strategy.COOKIE,
     navigateBefore: false,
     args: [
-        { name: 'note-id', required: true, positional: true, help: 'Note ID or full URL (preserves xsec_token for access)' },
+        { name: 'note-id', required: true, positional: true, help: 'Full Xiaohongshu note URL with xsec_token' },
         { name: 'limit', type: 'int', default: 20, help: 'Number of top-level comments (max 50)' },
         { name: 'with-replies', type: 'boolean', default: false, help: 'Include nested replies (楼中楼)' },
     ],
@@ -32,7 +32,7 @@ cli({
         const withReplies = Boolean(kwargs['with-replies']);
         const raw = String(kwargs['note-id']);
         const noteId = parseNoteId(raw);
-        await page.goto(buildNoteUrl(raw));
+        await page.goto(buildNoteUrl(raw, { commandName: 'xiaohongshu comments' }));
         await page.wait({ time: 2 + Math.random() * 3 });
         const data = await page.evaluate(`
       (async () => {