@jackwener/opencli 1.3.1 → 1.3.2

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

@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+function createPageMock(evaluateResults) {
+    const evaluate = vi.fn();
+    for (const result of evaluateResults) {
+        evaluate.mockResolvedValueOnce(result);
+    }
+    return {
+        goto: vi.fn().mockResolvedValue(undefined),
+        evaluate,
+        snapshot: vi.fn().mockResolvedValue(undefined),
+        click: vi.fn().mockResolvedValue(undefined),
+        typeText: vi.fn().mockResolvedValue(undefined),
+        pressKey: vi.fn().mockResolvedValue(undefined),
+        scrollTo: vi.fn().mockResolvedValue(undefined),
+        getFormState: vi.fn().mockResolvedValue({ forms: [], orphanFields: [] }),
+        wait: vi.fn().mockResolvedValue(undefined),
+        tabs: vi.fn().mockResolvedValue([]),
+        closeTab: vi.fn().mockResolvedValue(undefined),
+        newTab: vi.fn().mockResolvedValue(undefined),
+        selectTab: vi.fn().mockResolvedValue(undefined),
+        networkRequests: vi.fn().mockResolvedValue([]),
+        consoleMessages: vi.fn().mockResolvedValue([]),
+        scroll: vi.fn().mockResolvedValue(undefined),
+        autoScroll: vi.fn().mockResolvedValue(undefined),
+        installInterceptor: vi.fn().mockResolvedValue(undefined),
+        getInterceptedRequests: vi.fn().mockResolvedValue([]),
+        getCookies: vi.fn().mockResolvedValue([]),
+        screenshot: vi.fn().mockResolvedValue(''),
+    };
+}
+describe('xiaohongshu search', () => {
+    it('throws a clear error when the search page is blocked by a login wall', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            {
+                loginWall: true,
+                results: [],
+            },
+        ]);
+        await expect(cmd.func(page, { query: '特斯拉', limit: 5 })).rejects.toThrow('Xiaohongshu search results are blocked behind a login wall');
+    });
+    it('returns ranked results with search_result url and author_url preserved', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const detailUrl = 'https://www.xiaohongshu.com/search_result/68e90be80000000004022e66?xsec_token=test-token&xsec_source=';
+        const authorUrl = 'https://www.xiaohongshu.com/user/profile/635a9c720000000018028b40?xsec_token=user-token&xsec_source=pc_search';
+        const page = createPageMock([
+            {
+                loginWall: false,
+                results: [
+                    {
+                        title: '某鱼买FSD被坑了4万',
+                        author: '随风',
+                        likes: '261',
+                        url: detailUrl,
+                        author_url: authorUrl,
+                    },
+                ],
+            },
+        ]);
+        const result = await cmd.func(page, { query: '特斯拉', limit: 1 });
+        // Should only do one goto (the search page itself), no per-note detail navigation
+        expect(page.goto.mock.calls).toHaveLength(1);
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: '某鱼买FSD被坑了4万',
+                author: '随风',
+                likes: '261',
+                url: detailUrl,
+                author_url: authorUrl,
+            },
+        ]);
+    });
+    it('filters out results with no title and respects the limit', async () => {
+        const cmd = getRegistry().get('xiaohongshu/search');
+        expect(cmd?.func).toBeTypeOf('function');
+        const page = createPageMock([
+            {
+                loginWall: false,
+                results: [
+                    {
+                        title: 'Result A',
+                        author: 'UserA',
+                        likes: '10',
+                        url: 'https://www.xiaohongshu.com/search_result/aaa',
+                        author_url: '',
+                    },
+                    {
+                        title: '',
+                        author: 'UserB',
+                        likes: '5',
+                        url: 'https://www.xiaohongshu.com/search_result/bbb',
+                        author_url: '',
+                    },
+                    {
+                        title: 'Result C',
+                        author: 'UserC',
+                        likes: '3',
+                        url: 'https://www.xiaohongshu.com/search_result/ccc',
+                        author_url: '',
+                    },
+                ],
+            },
+        ]);
+        const result = (await cmd.func(page, { query: '测试', limit: 1 }));
+        // limit=1 should return only the first valid-titled result
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({ rank: 1, title: 'Result A' });
+    });
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Yollomi AI background generator — POST /api/ai/ai-background-generator
+ */
+export {};

package/dist/clis/yollomi/background.js

@@ -0,0 +1,45 @@
+/**
+ * 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;
+        const prompt = kwargs.prompt;
+        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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

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

@@ -0,0 +1,5 @@
+/**
+ * Yollomi image editing — POST /api/ai/qwen-image-edit
+ * Matches frontend workspace-generator.tsx for qwen-image-edit model.
+ */
+export {};

package/dist/clis/yollomi/edit.js

@@ -0,0 +1,56 @@
+/**
+ * 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;
+        const prompt = kwargs.prompt;
+        const modelId = kwargs.model;
+        let body;
+        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 = 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, 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/dist/clis/yollomi/face-swap.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Yollomi face swap — POST /api/ai/face-swap
+ * Uses swap_image / input_image field names matching the frontend.
+ */
+export {};

package/dist/clis/yollomi/face-swap.js

@@ -0,0 +1,43 @@
+/**
+ * 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,
+            input_image: kwargs.target,
+        });
+        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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

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

@@ -0,0 +1,9 @@
+/**
+ * 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?, ... }
+ */
+export {};

package/dist/clis/yollomi/generate.js

@@ -0,0 +1,100 @@
+/**
+ * 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, downloadOutput, fmtBytes, MODEL_ROUTES } from './utils.js';
+function getDimensions(ratio) {
+    const map = {
+        '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;
+        const modelId = kwargs.model;
+        const ratio = kwargs.ratio;
+        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;
+        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;
+        }
+        else if (modelId === 'flux-kontext-pro') {
+            body = { prompt, output_format: 'jpg' };
+            if (kwargs.image)
+                body.imageUrl = kwargs.image;
+            if (ratio !== '1:1')
+                body.aspect_ratio = ratio;
+        }
+        else {
+            body = { prompt, aspect_ratio: ratio };
+            if (kwargs.image)
+                body.imageUrl = kwargs.image;
+        }
+        process.stderr.write(chalk.dim(`Generating with ${modelId}...\n`));
+        const data = await yollomiPost(page, apiPath, body);
+        const images = 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'];
+        const outputDir = kwargs.output;
+        const results = [];
+        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/dist/clis/yollomi/models.d.ts

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

package/dist/clis/yollomi/models.js

@@ -0,0 +1,33 @@
+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;
+        const rows = [];
+        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/dist/clis/yollomi/object-remover.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Yollomi object remover — POST /api/ai/object-remover
+ */
+export {};

package/dist/clis/yollomi/object-remover.js

@@ -0,0 +1,42 @@
+/**
+ * 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,
+            mask: kwargs.mask,
+        });
+        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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

package/dist/clis/yollomi/remove-bg.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Yollomi background removal — POST /api/ai/remove-bg (free, 0 credits)
+ */
+export {};

package/dist/clis/yollomi/remove-bg.js

@@ -0,0 +1,38 @@
+/**
+ * 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 });
+        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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

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

@@ -0,0 +1,4 @@
+/**
+ * Yollomi photo restoration — POST /api/ai/photo-restoration
+ */
+export {};

package/dist/clis/yollomi/restore.js

@@ -0,0 +1,38 @@
+/**
+ * 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 });
+        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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

package/dist/clis/yollomi/try-on.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Yollomi virtual try-on — POST /api/ai/virtual-try-on
+ */
+export {};

package/dist/clis/yollomi/try-on.js

@@ -0,0 +1,46 @@
+/**
+ * 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,
+            cloth_image: kwargs.cloth,
+            cloth_type: kwargs['cloth-type'],
+            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, filename);
+            return [{ status: 'saved', file: path.relative('.', fp), size: fmtBytes(size), url }];
+        }
+        catch {
+            return [{ status: 'download-failed', file: '-', size: '-', url }];
+        }
+    },
+});

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

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export {};