@jackwener/opencli 1.3.1 → 1.3.2

package/src/clis/xiaohongshu/search.ts

@@ -7,6 +7,7 @@
  */
 
 import { cli, Strategy } from '../../registry.js';
+import { AuthRequiredError } from '../../errors.js';
 
 cli({
   site: 'xiaohongshu',
@@ -18,7 +19,7 @@ cli({
     { name: 'query', required: true, positional: true, help: 'Search keyword' },
     { name: 'limit', type: 'int', default: 20, help: 'Number of results' },
   ],
-  columns: ['rank', 'title', 'author', 'likes'],
+  columns: ['rank', 'title', 'author', 'likes', 'url'],
   func: async (page, kwargs) => {
     const keyword = encodeURIComponent(kwargs.query);
     await page.goto(
@@ -29,34 +30,67 @@ cli({
     // Scroll a couple of times to load more results
     await page.autoScroll({ times: 2 });
 
-    const data = await page.evaluate(`
+    const payload = await page.evaluate(`
       (() => {
-        const notes = document.querySelectorAll('section.note-item');
+        const loginWall = /登录后查看搜索结果/.test(document.body.innerText || '');
+
+        const normalizeUrl = (href) => {
+          if (!href) return '';
+          if (href.startsWith('http://') || href.startsWith('https://')) return href;
+          if (href.startsWith('/')) return 'https://www.xiaohongshu.com' + href;
+          return '';
+        };
+
+        const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
+
         const results = [];
-        notes.forEach(el => {
+        const seen = new Set();
+
+        document.querySelectorAll('section.note-item').forEach(el => {
           // Skip "related searches" sections
           if (el.classList.contains('query-note-item')) return;
 
-          const titleEl = el.querySelector('.title, .note-title, a.title');
-          const nameEl = el.querySelector('.name, .author-name, .nick-name');
+          const titleEl = el.querySelector('.title, .note-title, a.title, .footer .title span');
+          const nameEl = el.querySelector('a.author .name, .name, .author-name, .nick-name, a.author');
           const likesEl = el.querySelector('.count, .like-count, .like-wrapper .count');
-          const linkEl = el.querySelector('a[href*="/explore/"], a[href*="/search_result/"], a[href*="/note/"]');
+          // Prefer search_result link (preserves xsec_token) over generic /explore/ link
+          const detailLinkEl =
+            el.querySelector('a.cover.mask') ||
+            el.querySelector('a[href*="/search_result/"]') ||
+            el.querySelector('a[href*="/explore/"]') ||
+            el.querySelector('a[href*="/note/"]');
+          const authorLinkEl = el.querySelector('a.author, a[href*="/user/profile/"]');
 
-          const href = linkEl?.getAttribute('href') || '';
-          const noteId = href.match(/\\/(?:explore|note)\\/([a-zA-Z0-9]+)/)?.[1] || '';
+          const url = normalizeUrl(detailLinkEl?.getAttribute('href') || '');
+          if (!url) return;
+
+          const key = url;
+          if (seen.has(key)) return;
+          seen.add(key);
 
           results.push({
-            title: (titleEl?.textContent || '').trim(),
-            author: (nameEl?.textContent || '').trim(),
-            likes: (likesEl?.textContent || '0').trim(),
-            url: noteId ? 'https://www.xiaohongshu.com/explore/' + noteId : '',
+            title: cleanText(titleEl?.textContent || ''),
+            author: cleanText(nameEl?.textContent || ''),
+            likes: cleanText(likesEl?.textContent || '0'),
+            url,
+            author_url: normalizeUrl(authorLinkEl?.getAttribute('href') || ''),
           });
         });
-        return results;
+
+        return {
+          loginWall,
+          results,
+        };
       })()
     `);
 
-    if (!Array.isArray(data)) return [];
+    if (!payload || typeof payload !== 'object') return [];
+
+    if ((payload as any).loginWall) {
+      throw new AuthRequiredError('www.xiaohongshu.com', 'Xiaohongshu search results are blocked behind a login wall');
+    }
+
+    const data: any[] = Array.isArray((payload as any).results) ? (payload as any).results : [];
     return data
       .filter((item: any) => item.title)
       .slice(0, kwargs.limit)

package/src/clis/yollomi/background.ts

@@ -0,0 +1,48 @@
+/**
+ * Yollomi AI background generator — POST /api/ai/ai-background-generator
+ */
+
+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: 'background',
+  description: 'Generate AI background for a product/object image (5 credits)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Image URL (upload via "opencli yollomi upload" first)' },
+    { name: 'prompt', default: '', help: 'Background description (optional)' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    const imageUrl = kwargs.image as string;
+    const prompt = kwargs.prompt as string;
+
+    process.stderr.write(chalk.dim('Generating background...\n'));
+    const data = await yollomiPost(page, '/api/ai/ai-background-generator', {
+      images: [imageUrl],
+      prompt: prompt || undefined,
+      aspect_ratio: '1:1',
+    });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Try a different image');
+
+    if (kwargs['no-download']) return [{ status: 'generated', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_bg_${Date.now()}.png`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/edit.ts

@@ -0,0 +1,58 @@
+/**
+ * Yollomi image editing — POST /api/ai/qwen-image-edit
+ * Matches frontend workspace-generator.tsx for qwen-image-edit model.
+ */
+
+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: 'edit',
+  description: 'Edit images with AI text prompts (Qwen image edit)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Input image URL (upload via "opencli yollomi upload" first)' },
+    { name: 'prompt', positional: true, required: true, help: 'Editing instruction (e.g. "Make it look vintage")' },
+    { name: 'model', default: 'qwen-image-edit', choices: ['qwen-image-edit', 'qwen-image-edit-plus'], help: 'Edit model' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'credits', 'url'],
+  func: async (page, kwargs) => {
+    const imageInput = kwargs.image as string;
+    const prompt = kwargs.prompt as string;
+    const modelId = kwargs.model as string;
+
+    let body: Record<string, unknown>;
+    if (modelId === 'qwen-image-edit-plus') {
+      body = { prompt, images: [imageInput] };
+    } else {
+      body = { image: imageInput, prompt, go_fast: true, output_format: 'png' };
+    }
+
+    const apiPath = modelId === 'qwen-image-edit-plus' ? '/api/ai/qwen-image-edit-plus' : '/api/ai/qwen-image-edit';
+    process.stderr.write(chalk.dim(`Editing with ${modelId}...\n`));
+    const data = await yollomiPost(page, apiPath, body);
+
+    const images: string[] = data.images || (data.image ? [data.image] : []);
+    if (!images.length) throw new CliError('EMPTY_RESPONSE', 'No result', 'Try a different prompt');
+
+    const credits = data.remainingCredits;
+    const url = images[0];
+    if (kwargs['no-download']) return [{ status: 'edited', file: '-', size: '-', credits: credits ?? '-', url }];
+
+    try {
+      const filename = `yollomi_edit_${Date.now()}.png`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, 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 }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', credits: credits ?? '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/face-swap.ts

@@ -0,0 +1,45 @@
+/**
+ * Yollomi face swap — POST /api/ai/face-swap
+ * Uses swap_image / input_image field names matching the frontend.
+ */
+
+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: 'face-swap',
+  description: 'Swap faces between two photos (3 credits)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'source', required: true, help: 'Source face image URL' },
+    { name: 'target', required: true, help: 'Target photo URL' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    process.stderr.write(chalk.dim('Swapping faces...\n'));
+    const data = await yollomiPost(page, '/api/ai/face-swap', {
+      swap_image: kwargs.source as string,
+      input_image: kwargs.target as string,
+    });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Make sure both images contain clear faces');
+
+    if (kwargs['no-download']) return [{ status: 'swapped', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_faceswap_${Date.now()}.jpg`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/generate.ts

@@ -0,0 +1,95 @@
+/**
+ * Yollomi text-to-image / image-to-image generation.
+ *
+ * Uses per-model routes exactly like the frontend:
+ *   POST /api/ai/z-image-turbo  { prompt, width, height, ... }
+ *   POST /api/ai/nano-banana    { prompt, aspect_ratio, ... }
+ *   POST /api/ai/flux-2-pro     { prompt, aspectRatio, imageUrl?, ... }
+ */
+
+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, resolveImageInput, downloadOutput, fmtBytes, MODEL_ROUTES } from './utils.js';
+
+function getDimensions(ratio: string): { width: number; height: number } {
+  const map: Record<string, [number, number]> = {
+    '1:1': [1024, 1024], '16:9': [1344, 768], '9:16': [768, 1344],
+    '4:3': [1152, 896], '3:4': [896, 1152],
+  };
+  const [w, h] = map[ratio] || [1024, 1024];
+  return { width: w, height: h };
+}
+
+cli({
+  site: 'yollomi',
+  name: 'generate',
+  description: 'Generate images with AI (text-to-image or image-to-image)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'prompt', positional: true, required: true, help: 'Text prompt describing the image' },
+    { name: 'model', default: 'z-image-turbo', help: 'Model ID (z-image-turbo, flux-schnell, nano-banana, flux-2-pro, ...)' },
+    { name: 'ratio', default: '1:1', choices: ['1:1', '16:9', '9:16', '4:3', '3:4'], help: 'Aspect ratio' },
+    { name: 'image', help: 'Input image URL for image-to-image (upload via "opencli yollomi upload" first)' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URLs, skip download' },
+  ],
+  columns: ['index', 'status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    const prompt = kwargs.prompt as string;
+    const modelId = kwargs.model as string;
+    const ratio = kwargs.ratio as string;
+
+    const apiPath = MODEL_ROUTES[modelId];
+    if (!apiPath) throw new CliError('INVALID_MODEL', `Unknown model: ${modelId}`, 'Run "opencli yollomi models --type image" to see available models');
+
+    let body: Record<string, unknown>;
+
+    if (modelId === 'z-image-turbo') {
+      const { width, height } = getDimensions(ratio);
+      body = { prompt, width, height, output_format: 'jpg', output_quality: 85, guidance_scale: 0, num_inference_steps: 8 };
+    } else if (modelId === 'flux-2-pro') {
+      body = { prompt, aspectRatio: ratio, outputNumber: 1 };
+      if (kwargs.image) body.imageUrl = kwargs.image as string;
+    } else if (modelId === 'flux-kontext-pro') {
+      body = { prompt, output_format: 'jpg' };
+      if (kwargs.image) body.imageUrl = kwargs.image as string;
+      if (ratio !== '1:1') body.aspect_ratio = ratio;
+    } else {
+      body = { prompt, aspect_ratio: ratio };
+      if (kwargs.image) body.imageUrl = kwargs.image as string;
+    }
+
+    process.stderr.write(chalk.dim(`Generating with ${modelId}...\n`));
+    const data = await yollomiPost(page, apiPath, body);
+
+    const images: string[] = data.images || (data.image ? [data.image] : []);
+    if (!images.length) throw new CliError('EMPTY_RESPONSE', 'No images returned', 'Try a different prompt or model');
+
+    const noDownload = kwargs['no-download'] as boolean;
+    const outputDir = kwargs.output as string;
+    const results: any[] = [];
+
+    for (let i = 0; i < images.length; i++) {
+      const url = images[i];
+      if (noDownload) {
+        results.push({ index: i + 1, status: 'generated', file: '-', size: '-', url });
+        continue;
+      }
+      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_${modelId}_${Date.now()}_${i + 1}${ext}`;
+        const { path: fp, size } = await downloadOutput(url, outputDir, filename);
+        results.push({ index: i + 1, status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url });
+      } catch {
+        results.push({ index: i + 1, status: 'download-failed', file: '-', size: '-', url });
+      }
+    }
+
+    if (data.remainingCredits !== undefined) process.stderr.write(chalk.dim(`Credits remaining: ${data.remainingCredits}\n`));
+    return results;
+  },
+});

package/src/clis/yollomi/models.ts

@@ -0,0 +1,38 @@
+import { cli, Strategy } from '../../registry.js';
+import { IMAGE_MODELS, VIDEO_MODELS, TOOL_MODELS } from './utils.js';
+
+cli({
+  site: 'yollomi',
+  name: 'models',
+  description: 'List available Yollomi AI models (image, video, tools)',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'type', default: 'all', choices: ['all', 'image', 'video', 'tool'], help: 'Filter by model type' },
+  ],
+  columns: ['type', 'model', 'credits', 'description'],
+  func: async (_page, kwargs) => {
+    const filter = kwargs.type as string;
+    const rows: { type: string; model: string; credits: number | string; description: string }[] = [];
+
+    if (filter === 'all' || filter === 'image') {
+      for (const [id, info] of Object.entries(IMAGE_MODELS)) {
+        rows.push({ type: 'image', model: id, credits: info.credits, description: info.description });
+      }
+    }
+
+    if (filter === 'all' || filter === 'video') {
+      for (const [id, info] of Object.entries(VIDEO_MODELS)) {
+        rows.push({ type: 'video', model: id, credits: info.credits, description: info.description });
+      }
+    }
+
+    if (filter === 'all' || filter === 'tool') {
+      for (const [id, info] of Object.entries(TOOL_MODELS)) {
+        rows.push({ type: 'tool', model: id, credits: info.credits, description: info.description });
+      }
+    }
+
+    return rows;
+  },
+});

package/src/clis/yollomi/object-remover.ts

@@ -0,0 +1,44 @@
+/**
+ * Yollomi object remover — POST /api/ai/object-remover
+ */
+
+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: 'object-remover',
+  description: 'Remove unwanted objects from images (3 credits)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Image URL' },
+    { name: 'mask', positional: true, required: true, help: 'Mask image URL (white = area to remove)' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    process.stderr.write(chalk.dim('Removing object...\n'));
+    const data = await yollomiPost(page, '/api/ai/object-remover', {
+      image: kwargs.image as string,
+      mask: kwargs.mask as string,
+    });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Check image and mask');
+
+    if (kwargs['no-download']) return [{ status: 'removed', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_removed_${Date.now()}.png`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/remove-bg.ts

@@ -0,0 +1,40 @@
+/**
+ * Yollomi background removal — POST /api/ai/remove-bg (free, 0 credits)
+ */
+
+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: 'remove-bg',
+  description: 'Remove image background with AI (free)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Image URL to remove background from' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    process.stderr.write(chalk.dim('Removing background...\n'));
+    const data = await yollomiPost(page, '/api/ai/remove-bg', { imageUrl: kwargs.image as string });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Check the input image URL');
+
+    if (kwargs['no-download']) return [{ status: 'processed', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_nobg_${Date.now()}.png`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/restore.ts

@@ -0,0 +1,40 @@
+/**
+ * Yollomi photo restoration — POST /api/ai/photo-restoration
+ */
+
+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: 'restore',
+  description: 'Restore old or damaged photos with AI (4 credits)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'image', positional: true, required: true, help: 'Image URL to restore' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    process.stderr.write(chalk.dim('Restoring photo...\n'));
+    const data = await yollomiPost(page, '/api/ai/photo-restoration', { imageUrl: kwargs.image as string });
+
+    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: 'restored', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_restored_${Date.now()}.jpg`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/try-on.ts

@@ -0,0 +1,48 @@
+/**
+ * Yollomi virtual try-on — POST /api/ai/virtual-try-on
+ */
+
+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: 'try-on',
+  description: 'Virtual try-on — see how clothes look on a person (3 credits)',
+  domain: YOLLOMI_DOMAIN,
+  strategy: Strategy.COOKIE,
+  args: [
+    { name: 'person', required: true, help: 'Person photo URL (upload via "opencli yollomi upload" first)' },
+    { name: 'cloth', required: true, help: 'Clothing image URL' },
+    { name: 'cloth-type', default: 'upper', choices: ['upper', 'lower', 'overall'], help: 'Clothing type' },
+    { name: 'output', default: './yollomi-output', help: 'Output directory' },
+    { name: 'no-download', type: 'boolean', default: false, help: 'Only show URL' },
+  ],
+  columns: ['status', 'file', 'size', 'url'],
+  func: async (page, kwargs) => {
+    process.stderr.write(chalk.dim('Processing virtual try-on...\n'));
+    const data = await yollomiPost(page, '/api/ai/virtual-try-on', {
+      person_image: kwargs.person as string,
+      cloth_image: kwargs.cloth as string,
+      cloth_type: kwargs['cloth-type'] as string,
+      output_format: 'png',
+      output_quality: 100,
+    });
+
+    const url = data.image || (data.images?.[0]);
+    if (!url) throw new CliError('EMPTY_RESPONSE', 'No result', 'Check both images have clear subjects');
+
+    if (kwargs['no-download']) return [{ status: 'generated', file: '-', size: '-', url }];
+
+    try {
+      const filename = `yollomi_tryon_${Date.now()}.png`;
+      const { path: fp, size } = await downloadOutput(url, kwargs.output as string, filename);
+      return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+    } catch {
+      return [{ status: 'download-failed', file: '-', size: '-', url }];
+    }
+  },
+});

package/src/clis/yollomi/upload.ts

@@ -0,0 +1,78 @@
+/**
+ * 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: Record<string, string> = {
+  '.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 as string);
+    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 }];
+  },
+});