@jackwener/opencli 1.3.1 → 1.3.2

package/src/clis/yollomi/upscale.ts

@@ -0,0 +1,49 @@
+/**
+ * Yollomi image upscaling — POST /api/ai/image-upscaler
+ */
+
+import * as path from 'node:path';
+import chalk from 'chalk';
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { YOLLOMI_DOMAIN, yollomiPost, downloadOutput, fmtBytes } from './utils.js';
+
+cli({
+  site: 'yollomi',
+  name: 'upscale',
+  description: 'Upscale image resolution with AI (1 credit)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Image URL to upscale' },
+    { name: 'scale', default: '2', choices: ['2', '4'], help: 'Upscale factor (2 or 4)' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'scale', 'url'],
+  func: async (page, kwargs) => {
+    const scale = parseInt(kwargs.scale as string, 10);
+    process.stderr.write(chalk.dim(`Upscaling ${scale}x...\n`));
+    const data = await yollomiPost(page, '/api/ai/image-upscaler', {
+      imageUrl: kwargs.image as string,
+      scale,
+      face_enhance: false,
+    });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Check the input image');
+
+    if (kwargs['no-download']) return [{ status: 'upscaled', file: '-', size: '-', scale: `${scale}x`, url }];
+
+    try {
+      const urlPath = (() => { try { return new URL(url).pathname; } catch { return url; } })();
+      const ext = urlPath.endsWith('.png') || urlPath.endsWith('.webp') ? urlPath.slice(urlPath.lastIndexOf('.')) : '.jpg';
+      const filename = `yollomi_upscale_${scale}x_${Date.now()}${ext}`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      if (data.remainingCredits !== undefined) process.stderr.write(chalk.dim(`Credits remaining: ${data.remainingCredits}\n`));
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), scale: `${scale}x`, url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', scale: `${scale}x`, url }];
+    }
+  },
+});

package/src/clis/yollomi/utils.ts

@@ -0,0 +1,202 @@
+/**
+ * Yollomi API utilities — browser cookie strategy.
+ *
+ * Uses the same per-model API routes as the Yollomi frontend:
+ *   POST /api/ai/<model>   — image generation (session cookie auth)
+ *   POST /api/ai/video     — video generation (session cookie auth)
+ *
+ * Auth: browser session cookies from NextAuth — just log in to yollomi.com in Chrome.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { IPage } from '../../types.js';
+import { CliError } from '../../errors.js';
+
+export const YOLLOMI_DOMAIN = 'yollomi.com';
+
+/**
+ * Ensure the browser tab is on yollomi.com.
+ * The framework pre-nav sometimes silently fails, leaving the page on about:blank.
+ */
+export async function ensureOnYollomi(page: IPage): Promise<void> {
+  const currentUrl = await page.evaluate(`(() => location.href)()`) as string;
+  if (!currentUrl || !currentUrl.includes('yollomi.com')) {
+    await page.goto('https://yollomi.com');
+    await page.wait(3);
+  }
+}
+
+/**
+ * POST to a Yollomi /api/ai/* route via the browser session.
+ * Uses relative paths (e.g. `/api/ai/flux`) — same as the frontend.
+ */
+export async function yollomiPost(page: IPage, apiPath: string, body: Record<string, unknown>): Promise<any> {
+  const bodyJson = JSON.stringify(body);
+  await ensureOnYollomi(page);
+
+  const result = await page.evaluate(`
+    (async () => {
+      try {
+        const res = await fetch(${JSON.stringify(apiPath)}, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          credentials: 'include',
+          body: ${JSON.stringify(bodyJson)},
+        });
+        const text = await res.text();
+        return { ok: res.ok, status: res.status, body: text };
+      } catch (err) {
+        return { ok: false, status: 0, body: err.message || 'fetch failed (on ' + location.href + ')' };
+      }
+    })()
+  `);
+
+  if (!result || result.status === 0) {
+    throw new CliError(
+      'FETCH_ERROR',
+      `Network error: ${result?.body || 'Failed to fetch'}`,
+      'Make sure Chrome is logged in to https://yollomi.com and the Browser Bridge is running',
+    );
+  }
+
+  if (!result.ok) {
+    let detail = result.body;
+    try { detail = JSON.parse(result.body)?.error || JSON.parse(result.body)?.message || result.body; } catch {}
+    throw new CliError(
+      'API_ERROR',
+      `Yollomi API ${result.status}: ${detail}`,
+      result.status === 401
+        ? 'Not logged in — open Chrome, go to https://yollomi.com and log in'
+        : result.status === 402
+          ? 'Insufficient credits — top up at https://yollomi.com/pricing'
+          : result.status === 429
+            ? 'Rate limited — wait a moment and retry'
+            : 'Check the model and parameters',
+    );
+  }
+
+  try {
+    return JSON.parse(result.body);
+  } catch {
+    throw new CliError('API_ERROR', 'Invalid JSON response', 'Try again');
+  }
+}
+
+/**
+ * Resolve an image input: local file → base64 data URL, URL → as-is.
+ */
+export function resolveImageInput(input: string): string {
+  if (input.startsWith('http://') || input.startsWith('https://') || input.startsWith('data:')) {
+    return input;
+  }
+
+  const resolved = path.resolve(input);
+  if (!fs.existsSync(resolved)) {
+    throw new CliError('FILE_NOT_FOUND', `File not found: ${resolved}`, 'Provide a valid file path or URL');
+  }
+
+  const ext = path.extname(resolved).toLowerCase();
+  const mimeMap: Record<string, string> = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.png': 'image/png', '.gif': 'image/gif',
+    '.webp': 'image/webp', '.bmp': 'image/bmp',
+  };
+  const mime = mimeMap[ext] || 'image/png';
+  const data = fs.readFileSync(resolved);
+  return `data:${mime};base64,${data.toString('base64')}`;
+}
+
+export async function downloadOutput(
+  url: string, outputDir: string, filename: string,
+): Promise<{ path: string; size: number }> {
+  fs.mkdirSync(outputDir, { recursive: true });
+  const destPath = path.join(outputDir, filename);
+  const resp = await fetch(url);
+  if (!resp.ok) throw new CliError('DOWNLOAD_ERROR', `Download failed: HTTP ${resp.status}`, 'URL may have expired');
+  const buffer = Buffer.from(await resp.arrayBuffer());
+  fs.writeFileSync(destPath, buffer);
+  return { path: destPath, size: buffer.length };
+}
+
+export function fmtBytes(bytes: number): string {
+  if (bytes === 0) return '0 B';
+  const k = 1024;
+  const sizes = ['B', 'KB', 'MB', 'GB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+
+/** Per-model API route mapping (matches frontend model.apiEndpoint). */
+export const MODEL_ROUTES: Record<string, string> = {
+  'flux':                      '/api/ai/flux',
+  'flux-schnell':              '/api/ai/flux-schnell',
+  'flux-2-pro':                '/api/ai/flux-2-pro',
+  'flux-kontext-pro':          '/api/ai/flux-kontext-pro',
+  'nano-banana':               '/api/ai/nano-banana',
+  'nano-banana-pro':           '/api/ai/nano-banana-pro',
+  'nano-banana-2':             '/api/ai/nano-banana-2',
+  'z-image-turbo':             '/api/ai/z-image-turbo',
+  'imagen-4-ultra':            '/api/ai/imagen-4-ultra',
+  'imagen-4-fast':             '/api/ai/imagen-4-fast',
+  'ideogram-v3-turbo':         '/api/ai/ideogram-v3-turbo',
+  'stable-diffusion-3-5-large':'/api/ai/stable-diffusion-3-5-large',
+  'seedream-4-5':              '/api/ai/seedream-4-5',
+  'seedream-5-lite':           '/api/ai/seedream-5-lite',
+  'qwen-image-edit':           '/api/ai/qwen-image-edit',
+  'qwen-image-edit-plus':      '/api/ai/qwen-image-edit-plus',
+  'remove-bg':                 '/api/ai/remove-bg',
+  'image-upscaler':            '/api/ai/image-upscaler',
+  'face-swap':                 '/api/ai/face-swap',
+  'virtual-try-on':            '/api/ai/virtual-try-on',
+  'photo-restoration':         '/api/ai/photo-restoration',
+  'ai-background-generator':   '/api/ai/ai-background-generator',
+  'object-remover':            '/api/ai/object-remover',
+};
+
+/** Well-known image model IDs and their credit costs. */
+export const IMAGE_MODELS: Record<string, { credits: number; description: string }> = {
+  'z-image-turbo':             { credits: 1,  description: 'Alibaba Qwen turbo (cheapest, 1 credit)' },
+  'flux-schnell':              { credits: 2,  description: 'High-speed Flux generation' },
+  'ideogram-v3-turbo':         { credits: 3,  description: 'Ideogram V3 Turbo' },
+  'imagen-4-fast':             { credits: 3,  description: 'Google Imagen 4 Fast' },
+  'seedream-4-5':              { credits: 4,  description: 'Seedream 4.5 (ByteDance)' },
+  'seedream-5-lite':           { credits: 4,  description: 'Seedream 5 Lite — 2K/3K' },
+  'flux':                      { credits: 4,  description: 'Flux 1.1 Pro' },
+  'nano-banana':               { credits: 4,  description: 'Google Nano Banana' },
+  'flux-kontext-pro':          { credits: 4,  description: 'Flux Kontext Pro (img2img)' },
+  'imagen-4-ultra':            { credits: 6,  description: 'Google Imagen 4 Ultra' },
+  'nano-banana-2':             { credits: 7,  description: 'Google Nano Banana 2' },
+  'stable-diffusion-3-5-large':{ credits: 7,  description: 'Stable Diffusion 3.5 Large' },
+  'nano-banana-pro':           { credits: 15, description: 'Nano Banana Pro' },
+  'flux-2-pro':                { credits: 15, description: 'Flux 2 Pro (premium)' },
+};
+
+export const VIDEO_MODELS: Record<string, { credits: number; description: string }> = {
+  'kling-v2-6-motion-control':     { credits: 7,  description: 'Kling v2.6 Motion Control' },
+  'bytedance-seedance-1-pro-fast': { credits: 8,  description: 'Seedance 1.0 Pro Fast' },
+  'kling-2-1':                     { credits: 9,  description: 'Kling 2.1' },
+  'minimax-hailuo-2-3':            { credits: 9,  description: 'Hailuo 2.3' },
+  'pixverse-5':                    { credits: 9,  description: 'PixVerse 5' },
+  'wan-2-5-t2v':                   { credits: 9,  description: 'Wan 2.5 Text-to-Video' },
+  'wan-2-5-i2v':                   { credits: 9,  description: 'Wan 2.5 Image-to-Video' },
+  'google-veo-3-fast':             { credits: 9,  description: 'Google Veo 3 Fast' },
+  'google-veo-3-1-fast':           { credits: 9,  description: 'Google Veo 3.1 Fast' },
+  'openai-sora-2':                 { credits: 10, description: 'Sora 2' },
+  'google-veo-3':                  { credits: 10, description: 'Google Veo 3' },
+  'google-veo-3-1':                { credits: 10, description: 'Google Veo 3.1' },
+  'wan-2-6-t2v':                   { credits: 29, description: 'Wan 2.6 T2V (premium)' },
+  'wan-2-6-i2v':                   { credits: 29, description: 'Wan 2.6 I2V (premium)' },
+};
+
+export const TOOL_MODELS: Record<string, { credits: number; description: string }> = {
+  'remove-bg':              { credits: 0, description: 'Remove background (free)' },
+  'image-upscaler':         { credits: 1, description: 'Enhance image resolution' },
+  'object-remover':         { credits: 3, description: 'Remove unwanted objects' },
+  'face-swap':              { credits: 3, description: 'Swap faces in photos' },
+  'virtual-try-on':         { credits: 3, description: 'Try clothes on photos' },
+  'qwen-image-edit':        { credits: 3, description: 'Edit image with text prompt' },
+  'qwen-image-edit-plus':   { credits: 3, description: 'Advanced image editing' },
+  'photo-restoration':      { credits: 4, description: 'Revive old/damaged photos' },
+  'ai-background-generator':{ credits: 5, description: 'Generate custom backgrounds' },
+};

package/src/clis/yollomi/video.ts

@@ -0,0 +1,61 @@
+/**
+ * Yollomi video generation — POST /api/ai/video
+ * Matches the frontend video-generator.tsx request format exactly.
+ */
+
+import * as path from 'node:path';
+import chalk from 'chalk';
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { YOLLOMI_DOMAIN, yollomiPost, downloadOutput, fmtBytes } from './utils.js';
+
+cli({
+  site: 'yollomi',
+  name: 'video',
+  description: 'Generate videos with AI (text-to-video or image-to-video)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'prompt', positional: true, required: true, help: 'Text prompt describing the video' },
+    { name: 'model', default: 'kling-2-1', help: 'Model (kling-2-1, openai-sora-2, google-veo-3-1, wan-2-5-t2v, ...)' },
+    { name: 'image', help: 'Input image URL for image-to-video' },
+    { name: 'ratio', default: '16:9', choices: ['1:1', '16:9', '9:16', '4:3', '3:4'], help: 'Aspect ratio' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL, skip download' },
+  ],
+  columns: ['status', 'file', 'size', 'credits', 'url'],
+  func: async (page, kwargs) => {
+    const prompt = kwargs.prompt as string;
+    const modelId = kwargs.model as string;
+
+    const inputs: Record<string, unknown> = {
+      aspect_ratio: kwargs.ratio as string,
+    };
+    if (kwargs.image) inputs.image = kwargs.image as string;
+
+    const body = { modelId, prompt, inputs };
+
+    process.stderr.write(chalk.dim(`Generating video with ${modelId} (may take a while)...\n`));
+    const data = await yollomiPost(page, '/api/ai/video', body);
+
+    const videoUrl: string = data.video || '';
+    if (!videoUrl) throw new CliError('EMPTY_RESPONSE', 'No video returned', 'Try a different prompt or model');
+
+    const credits = data.remainingCredits;
+    const noDownload = kwargs['no-download'] as boolean;
+    const outputDir = kwargs.output as string;
+
+    if (noDownload) {
+      return [{ status: 'generated', file: '-', size: '-', credits: credits ?? '-', url: videoUrl }];
+    }
+
+    try {
+      const filename = `yollomi_${modelId}_${Date.now()}.mp4`;
+      const { path: fp, size } = await downloadOutput(videoUrl, outputDir, filename);
+      if (credits !== undefined) process.stderr.write(chalk.dim(`Credits remaining: ${credits}\n`));
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), credits: credits ?? '-', url: videoUrl }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', credits: credits ?? '-', url: videoUrl }];
+    }
+  },
+});

package/src/clis/zhihu/download.test.ts

@@ -1,12 +1,14 @@
 import { describe, expect, it } from 'vitest';
-import { htmlToMarkdown } from './download.js';
+import TurndownService from 'turndown';
 
-describe('htmlToMarkdown', () => {
+describe('article markdown conversion', () => {
   it('renders ordered lists with the original list item content', () => {
     const html = '<ol><li>First item</li><li>Second item</li></ol>';
+    const td = new TurndownService({ headingStyle: 'atx', bulletListMarker: '-' });
+    const md = td.turndown(html);
 
-    expect(htmlToMarkdown(html)).toContain('1. First item');
-    expect(htmlToMarkdown(html)).toContain('2. Second item');
-    expect(htmlToMarkdown(html)).not.toContain('$1');
+    expect(md).toMatch(/1\.\s+First item/);
+    expect(md).toMatch(/2\.\s+Second item/);
+    expect(md).not.toContain('$1');
   });
 });

package/src/clis/zhihu/download.ts

@@ -5,85 +5,8 @@
  *   opencli zhihu download --url "https://zhuanlan.zhihu.com/p/xxx" --output ./zhihu
  */
 
-import * as fs from 'node:fs';
-import * as path from 'node:path';
 import { cli, Strategy } from '../../registry.js';
-import { sanitizeFilename, httpDownload, formatCookieHeader } from '../../download/index.js';
-import { formatBytes } from '../../download/progress.js';
-
-/**
- * Convert HTML content to Markdown.
- * This is a simplified converter for Zhihu article content.
- */
-export function htmlToMarkdown(html: string): string {
-  let md = html;
-
-  // Remove script and style tags
-  md = md.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
-  md = md.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
-
-  // Convert headers
-  md = md.replace(/<h1[^>]*>(.*?)<\/h1>/gi, '# $1\n\n');
-  md = md.replace(/<h2[^>]*>(.*?)<\/h2>/gi, '## $1\n\n');
-  md = md.replace(/<h3[^>]*>(.*?)<\/h3>/gi, '### $1\n\n');
-  md = md.replace(/<h4[^>]*>(.*?)<\/h4>/gi, '#### $1\n\n');
-
-  // Convert paragraphs
-  md = md.replace(/<p[^>]*>([\s\S]*?)<\/p>/gi, '$1\n\n');
-
-  // Convert links
-  md = md.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, '[$2]($1)');
-
-  // Convert images
-  md = md.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, '![$2]($1)');
-  md = md.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, '![]($1)');
-
-  // Convert lists
-  md = md.replace(/<ul[^>]*>([\s\S]*?)<\/ul>/gi, (match, content) => {
-    return content.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '- $1\n') + '\n';
-  });
-  md = md.replace(/<ol[^>]*>([\s\S]*?)<\/ol>/gi, (match, content) => {
-    let index = 0;
-    return content.replace(
-      /<li[^>]*>([\s\S]*?)<\/li>/gi,
-      (_itemMatch: string, itemContent: string) => `${++index}. ${itemContent}\n`,
-    ) + '\n';
-  });
-
-  // Convert bold and italic
-  md = md.replace(/<strong[^>]*>(.*?)<\/strong>/gi, '**$1**');
-  md = md.replace(/<b[^>]*>(.*?)<\/b>/gi, '**$1**');
-  md = md.replace(/<em[^>]*>(.*?)<\/em>/gi, '*$1*');
-  md = md.replace(/<i[^>]*>(.*?)<\/i>/gi, '*$1*');
-
-  // Convert code blocks
-  md = md.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, '```\n$1\n```\n\n');
-  md = md.replace(/<code[^>]*>(.*?)<\/code>/gi, '`$1`');
-
-  // Convert blockquotes
-  md = md.replace(/<blockquote[^>]*>([\s\S]*?)<\/blockquote>/gi, (match, content) => {
-    return content.split('\n').map((line: string) => `> ${line}`).join('\n') + '\n\n';
-  });
-
-  // Convert line breaks
-  md = md.replace(/<br\s*\/?>/gi, '\n');
-
-  // Remove remaining HTML tags
-  md = md.replace(/<[^>]+>/g, '');
-
-  // Decode HTML entities
-  md = md.replace(/&nbsp;/g, ' ');
-  md = md.replace(/&lt;/g, '<');
-  md = md.replace(/&gt;/g, '>');
-  md = md.replace(/&amp;/g, '&');
-  md = md.replace(/&quot;/g, '"');
-
-  // Clean up extra whitespace
-  md = md.replace(/\n{3,}/g, '\n\n');
-  md = md.trim();
-
-  return md;
-}
+import { downloadArticle } from '../../download/article-download.js';
 
 cli({
   site: 'zhihu',
@@ -92,18 +15,17 @@ cli({
   domain: 'zhuanlan.zhihu.com',
   strategy: Strategy.COOKIE,
   args: [
-    { name: 'url', required: true, positional: true, help: 'Article URL (zhuanlan.zhihu.com/p/xxx)' },
+    { name: 'url', required: true, help: 'Article URL (zhuanlan.zhihu.com/p/xxx)' },
     { name: 'output', default: './zhihu-articles', help: 'Output directory' },
     { name: 'download-images', type: 'boolean', default: false, help: 'Download images locally' },
   ],
-  columns: ['title', 'author', 'status', 'size'],
+  columns: ['title', 'author', 'publish_time', 'status', 'size'],
   func: async (page, kwargs) => {
     const url = kwargs.url;
-    const output = kwargs.output;
-    const downloadImages = kwargs['download-images'];
 
     // Navigate to article page
     await page.goto(url);
+    await page.wait(3);
 
     // Extract article content
     const data = await page.evaluate(`
@@ -111,9 +33,9 @@ cli({
         const result = {
           title: '',
           author: '',
-          content: '',
           publishTime: '',
-          images: []
+          contentHtml: '',
+          imageUrls: []
         };
 
         // Get title
@@ -131,13 +53,13 @@ cli({
         // Get content HTML
         const contentEl = document.querySelector('.Post-RichTextContainer, .RichText, .ArticleContent');
         if (contentEl) {
-          result.content = contentEl.innerHTML;
+          result.contentHtml = contentEl.innerHTML;
 
           // Extract image URLs
           contentEl.querySelectorAll('img').forEach(img => {
             const src = img.getAttribute('data-original') || img.getAttribute('data-actualsrc') || img.src;
             if (src && !src.includes('data:image')) {
-              result.images.push(src);
+              result.imageUrls.push(src);
             }
           });
         }
@@ -146,77 +68,20 @@ cli({
       })()
     `);
 
-    if (!data || !data.content) {
-      return [{
-        title: 'Error',
-        author: '-',
-        status: 'failed',
-        size: 'Could not extract article content',
-      }];
-    }
-
-    // Create output directory
-    fs.mkdirSync(output, { recursive: true });
-
-    // Convert HTML to Markdown
-    let markdown = htmlToMarkdown(data.content);
-
-    // Create frontmatter
-    const frontmatter = [
-      '---',
-      `title: "${data.title.replace(/"/g, '\\"')}"`,
-      `author: "${data.author.replace(/"/g, '\\"')}"`,
-      `source: "${url}"`,
-      data.publishTime ? `date: "${data.publishTime}"` : '',
-      '---',
-      '',
-    ].filter(Boolean).join('\n');
-
-    // Download images if requested
-    if (downloadImages && data.images && data.images.length > 0) {
-      const imagesDir = path.join(output, 'images');
-      fs.mkdirSync(imagesDir, { recursive: true });
-
-      const cookies = formatCookieHeader(await page.getCookies({ domain: 'zhihu.com' }));
-
-      for (let i = 0; i < data.images.length; i++) {
-        const imgUrl = data.images[i];
-        const ext = imgUrl.match(/\.(jpg|jpeg|png|gif|webp)/i)?.[1] || 'jpg';
-        const imgFilename = `img_${i + 1}.${ext}`;
-        const imgPath = path.join(imagesDir, imgFilename);
-
-        try {
-          await httpDownload(imgUrl, imgPath, {
-            cookies,
-            timeout: 30000,
-          });
-
-          // Replace image URL in markdown with local path
-          markdown = markdown.replace(
-            new RegExp(imgUrl.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'),
-            `./images/${imgFilename}`,
-          );
-        } catch {
-          // Keep original URL if download fails
-        }
-      }
-    }
-
-    // Write markdown file
-    const safeTitle = sanitizeFilename(data.title, 100);
-    const filename = `${safeTitle}.md`;
-    const filePath = path.join(output, filename);
-
-    const fullContent = frontmatter + '\n' + markdown;
-    fs.writeFileSync(filePath, fullContent, 'utf-8');
-
-    const size = Buffer.byteLength(fullContent, 'utf-8');
-
-    return [{
-      title: data.title,
-      author: data.author,
-      status: 'success',
-      size: formatBytes(size),
-    }];
+    return downloadArticle(
+      {
+        title: data?.title || '',
+        author: data?.author,
+        publishTime: data?.publishTime,
+        sourceUrl: url,
+        contentHtml: data?.contentHtml || '',
+        imageUrls: data?.imageUrls,
+      },
+      {
+        output: kwargs.output,
+        downloadImages: kwargs['download-images'],
+        imageHeaders: { Referer: 'https://zhuanlan.zhihu.com/' },
+      },
+    );
   },
 });

package/src/clis/zhihu/question.ts

@@ -1,4 +1,5 @@
 import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
 
 cli({
   site: 'zhihu',
@@ -31,7 +32,7 @@ cli({
       }
     `);
 
-    if (!result || result.error) throw new Error('Failed to fetch question. Are you logged in?');
+    if (!result || result.error) throw new AuthRequiredError('www.zhihu.com', 'Failed to fetch question data from Zhihu');
 
     const answers = (result.answers ?? []).slice(0, Number(limit)).map((a: any, i: number) => ({
       rank: i + 1,

package/src/commanderAdapter.ts

@@ -16,11 +16,7 @@ import { type CliCommand, fullName, getRegistry } from './registry.js';
 import { formatRegistryHelpText } from './serialization.js';
 import { render as renderOutput } from './output.js';
 import { executeCommand } from './execution.js';
-import { CliError } from './errors.js';
-
-function getErrorMessage(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
+import { CliError, ERROR_ICONS, getErrorMessage } from './errors.js';
 
 /**
  * Register a single CliCommand as a Commander subcommand.
@@ -90,8 +86,9 @@ export function registerCommandToProgram(siteCmd: Command, cmd: CliCommand): voi
       });
     } catch (err) {
       if (err instanceof CliError) {
-        console.error(chalk.red(`Error [${err.code}]: ${err.message}`));
-        if (err.hint) console.error(chalk.yellow(`Hint: ${err.hint}`));
+        const icon = ERROR_ICONS[err.code] ?? '⚠️';
+        console.error(chalk.red(`${icon} ${err.message}`));
+        if (err.hint) console.error(chalk.yellow(`→ ${err.hint}`));
       } else if (optionsRecord.verbose === true && err instanceof Error && err.stack) {
         console.error(chalk.red(err.stack));
       } else {

package/src/daemon.ts

@@ -150,11 +150,14 @@ async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise
         return;
       }
 
+      const timeoutMs = typeof body.timeout === 'number' && body.timeout > 0
+        ? body.timeout * 1000
+        : 120000;
       const result = await new Promise<unknown>((resolve, reject) => {
         const timer = setTimeout(() => {
           pending.delete(body.id);
-          reject(new Error('Command timeout (120s)'));
-        }, 120000);
+          reject(new Error(`Command timeout (${timeoutMs / 1000}s)`));
+        }, timeoutMs);
         pending.set(body.id, { resolve, reject, timer });
         extensionWs!.send(JSON.stringify(body));
       });