@jackwener/opencli 1.3.1 → 1.3.2

package/dist/clis/yollomi/upload.js

@@ -0,0 +1,71 @@
+/**
+ * Yollomi image upload — POST /api/upload (FormData)
+ *
+ * Uploads a local file to Yollomi's R2 storage and returns the URL.
+ * The URL can then be used as input for image-to-image, face-swap, etc.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import chalk from 'chalk';
+import { cli, Strategy } from '../../registry.js';
+import { CliError } from '../../errors.js';
+import { YOLLOMI_DOMAIN, ensureOnYollomi, fmtBytes } from './utils.js';
+const MIME_MAP = {
+    '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.png': 'image/png', '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.mp4': 'video/mp4', '.mov': 'video/quicktime',
+};
+cli({
+    site: 'yollomi',
+    name: 'upload',
+    description: 'Upload an image or video to Yollomi (returns URL for other commands)',
+    domain: YOLLOMI_DOMAIN,
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'file', positional: true, required: true, help: 'Local file path to upload' },
+    ],
+    columns: ['status', 'file', 'size', 'url'],
+    func: async (page, kwargs) => {
+        const filePath = path.resolve(kwargs.file);
+        if (!fs.existsSync(filePath))
+            throw new CliError('FILE_NOT_FOUND', `File not found: ${filePath}`, 'Provide a valid file path');
+        const ext = path.extname(filePath).toLowerCase();
+        const mime = MIME_MAP[ext];
+        if (!mime)
+            throw new CliError('INVALID_TYPE', `Unsupported file type: ${ext}`, 'Supported: jpg, png, gif, webp, mp4, mov');
+        const data = fs.readFileSync(filePath);
+        // Note: base64 encoding inflates size ~33%. Video cap is conservative to avoid
+        // OOM when the base64 string is injected into the browser JS engine via page.evaluate().
+        const maxSize = mime.startsWith('video/') ? 20 * 1024 * 1024 : 10 * 1024 * 1024;
+        if (data.length > maxSize)
+            throw new CliError('FILE_TOO_LARGE', `File too large: ${fmtBytes(data.length)}`, `Max ${mime.startsWith('video/') ? '20MB' : '10MB'} (upload larger videos from a URL)`);
+        const b64 = data.toString('base64');
+        const fileName = path.basename(filePath);
+        process.stderr.write(chalk.dim(`Uploading ${fileName} (${fmtBytes(data.length)})...\n`));
+        await ensureOnYollomi(page);
+        const result = await page.evaluate(`
+      (async () => {
+        try {
+          const raw = atob(${JSON.stringify(b64)});
+          const arr = new Uint8Array(raw.length);
+          for (let i = 0; i < raw.length; i++) arr[i] = raw.charCodeAt(i);
+          const file = new File([arr], ${JSON.stringify(fileName)}, { type: ${JSON.stringify(mime)} });
+          const fd = new FormData();
+          fd.append('file', file);
+          const res = await fetch('/api/upload', { method: 'POST', body: fd, credentials: 'include' });
+          const json = await res.json();
+          return { ok: res.ok, status: res.status, data: json };
+        } catch (err) {
+          return { ok: false, status: 0, data: { error: err.message } };
+        }
+      })()
+    `);
+        if (!result?.ok) {
+            throw new CliError('UPLOAD_ERROR', result?.data?.error || 'Upload failed', 'Make sure you are logged in to yollomi.com');
+        }
+        const url = result.data.url;
+        process.stderr.write(chalk.green(`Uploaded! Use this URL as input for other commands.\n`));
+        return [{ status: 'uploaded', file: fileName, size: fmtBytes(data.length), url }];
+    },
+});

package/dist/clis/yollomi/upscale.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Yollomi image upscaling — POST /api/ai/image-upscaler
+ */
+export {};

package/dist/clis/yollomi/upscale.js

@@ -0,0 +1,53 @@
+/**
+ * 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, 10);
+        process.stderr.write(chalk.dim(`Upscaling ${scale}x...\n`));
+        const data = await yollomiPost(page, '/api/ai/image-upscaler', {
+            imageUrl: kwargs.image,
+            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, 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/dist/clis/yollomi/utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 type { IPage } from '../../types.js';
+export declare 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 declare function ensureOnYollomi(page: IPage): Promise<void>;
+/**
+ * POST to a Yollomi /api/ai/* route via the browser session.
+ * Uses relative paths (e.g. `/api/ai/flux`) — same as the frontend.
+ */
+export declare function yollomiPost(page: IPage, apiPath: string, body: Record<string, unknown>): Promise<any>;
+/**
+ * Resolve an image input: local file → base64 data URL, URL → as-is.
+ */
+export declare function resolveImageInput(input: string): string;
+export declare function downloadOutput(url: string, outputDir: string, filename: string): Promise<{
+    path: string;
+    size: number;
+}>;
+export declare function fmtBytes(bytes: number): string;
+/** Per-model API route mapping (matches frontend model.apiEndpoint). */
+export declare const MODEL_ROUTES: Record<string, string>;
+/** Well-known image model IDs and their credit costs. */
+export declare const IMAGE_MODELS: Record<string, {
+    credits: number;
+    description: string;
+}>;
+export declare const VIDEO_MODELS: Record<string, {
+    credits: number;
+    description: string;
+}>;
+export declare const TOOL_MODELS: Record<string, {
+    credits: number;
+    description: string;
+}>;

package/dist/clis/yollomi/utils.js

@@ -0,0 +1,180 @@
+/**
+ * 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 { 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) {
+    const currentUrl = await page.evaluate(`(() => location.href)()`);
+    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, apiPath, body) {
+    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) {
+    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 = {
+        '.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, outputDir, filename) {
+    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) {
+    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 = {
+    '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 = {
+    '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 = {
+    '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 = {
+    '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/dist/clis/yollomi/video.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Yollomi video generation — POST /api/ai/video
+ * Matches the frontend video-generator.tsx request format exactly.
+ */
+export {};

package/dist/clis/yollomi/video.js

@@ -0,0 +1,56 @@
+/**
+ * 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;
+        const modelId = kwargs.model;
+        const inputs = {
+            aspect_ratio: kwargs.ratio,
+        };
+        if (kwargs.image)
+            inputs.image = kwargs.image;
+        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 = 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'];
+        const outputDir = kwargs.output;
+        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/dist/clis/zhihu/download.d.ts

@@ -4,8 +4,4 @@
  * Usage:
  *   opencli zhihu download --url "https://zhuanlan.zhihu.com/p/xxx" --output ./zhihu
  */
-/**
- * Convert HTML content to Markdown.
- * This is a simplified converter for Zhihu article content.
- */
-export declare function htmlToMarkdown(html: string): string;
+export {};

package/dist/clis/zhihu/download.js

@@ -4,67 +4,8 @@
  * Usage:
  *   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) {
-    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, itemContent) => `${++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) => `> ${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',
     name: 'download',
@@ -72,26 +13,25 @@ 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(`
       (() => {
         const result = {
           title: '',
           author: '',
-          content: '',
           publishTime: '',
-          images: []
+          contentHtml: '',
+          imageUrls: []
         };
 
         // Get title
@@ -109,13 +49,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);
             }
           });
         }
@@ -123,63 +63,17 @@ cli({
         return result;
       })()
     `);
-        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/dist/clis/zhihu/download.test.js

@@ -1,10 +1,12 @@
 import { describe, expect, it } from 'vitest';
-import { htmlToMarkdown } from './download.js';
-describe('htmlToMarkdown', () => {
+import TurndownService from 'turndown';
+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>';
-        expect(htmlToMarkdown(html)).toContain('1. First item');
-        expect(htmlToMarkdown(html)).toContain('2. Second item');
-        expect(htmlToMarkdown(html)).not.toContain('$1');
+        const td = new TurndownService({ headingStyle: 'atx', bulletListMarker: '-' });
+        const md = td.turndown(html);
+        expect(md).toMatch(/1\.\s+First item/);
+        expect(md).toMatch(/2\.\s+Second item/);
+        expect(md).not.toContain('$1');
     });
 });

package/dist/clis/zhihu/question.js

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