@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/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/vendor/opencli/dist/clis/yollomi/upscale.d.ts

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

package/vendor/opencli/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/vendor/opencli/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/vendor/opencli/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/vendor/opencli/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/vendor/opencli/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/vendor/opencli/dist/clis/youtube/channel.d.ts

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

package/vendor/opencli/dist/clis/youtube/channel.js

@@ -0,0 +1,150 @@
+/**
+ * YouTube channel — get channel info and recent videos via InnerTube API.
+ */
+import { cli, Strategy } from '../../registry.js';
+import { CommandExecutionError } from '../../errors.js';
+cli({
+    site: 'youtube',
+    name: 'channel',
+    description: 'Get YouTube channel info and recent videos',
+    domain: 'www.youtube.com',
+    strategy: Strategy.COOKIE,
+    args: [
+        { name: 'id', required: true, positional: true, help: 'Channel ID (UCxxxx) or handle (@name)' },
+        { name: 'limit', type: 'int', default: 10, help: 'Max recent videos (max 30)' },
+    ],
+    columns: ['field', 'value'],
+    func: async (page, kwargs) => {
+        const channelId = String(kwargs.id);
+        const limit = Math.min(kwargs.limit || 10, 30);
+        await page.goto('https://www.youtube.com');
+        await page.wait(2);
+        const data = await page.evaluate(`
+      (async () => {
+        const channelId = ${JSON.stringify(channelId)};
+        const limit = ${limit};
+        const cfg = window.ytcfg?.data_ || {};
+        const apiKey = cfg.INNERTUBE_API_KEY;
+        const context = cfg.INNERTUBE_CONTEXT;
+        if (!apiKey || !context) return {error: 'YouTube config not found'};
+
+        // Resolve handle to browseId if needed
+        let browseId = channelId;
+        if (channelId.startsWith('@')) {
+          const resolveResp = await fetch('/youtubei/v1/navigation/resolve_url?key=' + apiKey + '&prettyPrint=false', {
+            method: 'POST', credentials: 'include',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({context, url: 'https://www.youtube.com/' + channelId})
+          });
+          if (resolveResp.ok) {
+            const resolveData = await resolveResp.json();
+            browseId = resolveData.endpoint?.browseEndpoint?.browseId || channelId;
+          }
+        }
+
+        // Fetch channel data
+        const resp = await fetch('/youtubei/v1/browse?key=' + apiKey + '&prettyPrint=false', {
+          method: 'POST', credentials: 'include',
+          headers: {'Content-Type': 'application/json'},
+          body: JSON.stringify({context, browseId})
+        });
+        if (!resp.ok) return {error: 'Channel API returned HTTP ' + resp.status};
+        const data = await resp.json();
+
+        // Channel metadata
+        const metadata = data.metadata?.channelMetadataRenderer || {};
+        const header = data.header?.pageHeaderRenderer || data.header?.c4TabbedHeaderRenderer || {};
+
+        // Subscriber count from header
+        let subscriberCount = '';
+        try {
+          const rows = header.content?.pageHeaderViewModel?.metadata?.contentMetadataViewModel?.metadataRows || [];
+          for (const row of rows) {
+            for (const part of (row.metadataParts || [])) {
+              const text = part.text?.content || '';
+              if (text.includes('subscriber')) subscriberCount = text;
+            }
+          }
+        } catch {}
+        // Fallback for old c4TabbedHeaderRenderer format
+        if (!subscriberCount && header.subscriberCountText?.simpleText) {
+          subscriberCount = header.subscriberCountText.simpleText;
+        }
+
+        // Extract recent videos from Home tab
+        const tabs = data.contents?.twoColumnBrowseResultsRenderer?.tabs || [];
+        const homeTab = tabs.find(t => t.tabRenderer?.selected);
+        const recentVideos = [];
+
+        if (homeTab) {
+          const sections = homeTab.tabRenderer?.content?.sectionListRenderer?.contents || [];
+          for (const section of sections) {
+            for (const shelf of (section.itemSectionRenderer?.contents || [])) {
+              for (const item of (shelf.shelfRenderer?.content?.horizontalListRenderer?.items || [])) {
+                // New lockupViewModel format
+                const lvm = item.lockupViewModel;
+                if (lvm && lvm.contentType === 'LOCKUP_CONTENT_TYPE_VIDEO' && recentVideos.length < limit) {
+                  const meta = lvm.metadata?.lockupMetadataViewModel;
+                  const rows = meta?.metadata?.contentMetadataViewModel?.metadataRows || [];
+                  const viewsAndTime = (rows[0]?.metadataParts || []).map(p => p.text?.content).filter(Boolean).join(' | ');
+                  let duration = '';
+                  for (const ov of (lvm.contentImage?.thumbnailViewModel?.overlays || [])) {
+                    for (const b of (ov.thumbnailBottomOverlayViewModel?.badges || [])) {
+                      if (b.thumbnailBadgeViewModel?.text) duration = b.thumbnailBadgeViewModel.text;
+                    }
+                  }
+                  recentVideos.push({
+                    title: meta?.title?.content || '',
+                    duration,
+                    views: viewsAndTime,
+                    url: 'https://www.youtube.com/watch?v=' + lvm.contentId,
+                  });
+                }
+                // Legacy gridVideoRenderer format
+                if (item.gridVideoRenderer && recentVideos.length < limit) {
+                  const v = item.gridVideoRenderer;
+                  recentVideos.push({
+                    title: v.title?.runs?.[0]?.text || v.title?.simpleText || '',
+                    duration: v.thumbnailOverlays?.[0]?.thumbnailOverlayTimeStatusRenderer?.text?.simpleText || '',
+                    views: (v.shortViewCountText?.simpleText || '') + (v.publishedTimeText?.simpleText ? ' | ' + v.publishedTimeText.simpleText : ''),
+                    url: 'https://www.youtube.com/watch?v=' + v.videoId,
+                  });
+                }
+              }
+            }
+          }
+        }
+
+        return {
+          name: metadata.title || '',
+          channelId: metadata.externalId || browseId,
+          handle: metadata.vanityChannelUrl?.split('/').pop() || '',
+          description: (metadata.description || '').substring(0, 500),
+          subscribers: subscriberCount,
+          url: metadata.channelUrl || 'https://www.youtube.com/channel/' + browseId,
+          keywords: metadata.keywords || '',
+          recentVideos,
+        };
+      })()
+    `);
+        if (!data || typeof data !== 'object')
+            throw new CommandExecutionError('Failed to fetch channel data');
+        if (data.error)
+            throw new CommandExecutionError(String(data.error));
+        const result = data;
+        const videos = result.recentVideos;
+        delete result.recentVideos;
+        // Channel info as field/value pairs + recent videos as table
+        const rows = Object.entries(result).map(([field, value]) => ({
+            field,
+            value: String(value),
+        }));
+        if (videos && videos.length > 0) {
+            rows.push({ field: '---', value: '--- Recent Videos ---' });
+            for (const v of videos) {
+                rows.push({ field: v.title, value: `${v.duration} | ${v.views} | ${v.url}` });
+            }
+        }
+        return rows;
+    },
+});

package/vendor/opencli/dist/clis/youtube/comments.d.ts

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