@huyuan-ai/cli 1.0.0 → 1.0.2

package/vendor/opencli/dist/download/index.test.js

@@ -0,0 +1,118 @@
+import * as fs from 'node:fs';
+import * as http from 'node:http';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { formatCookieHeader, httpDownload, resolveRedirectUrl } from './index.js';
+const servers = [];
+const tempDirs = [];
+afterEach(async () => {
+    vi.unstubAllEnvs();
+    await Promise.all(servers.map((server) => new Promise((resolve, reject) => {
+        server.close((err) => (err ? reject(err) : resolve()));
+    })));
+    servers.length = 0;
+    for (const dir of tempDirs) {
+        try {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+    }
+    tempDirs.length = 0;
+});
+async function startServer(handler, hostname = '127.0.0.1') {
+    const server = http.createServer(handler);
+    servers.push(server);
+    await new Promise((resolve) => server.listen(0, hostname, resolve));
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('Failed to start test server');
+    }
+    return `http://${hostname}:${address.port}`;
+}
+// Windows Defender can briefly lock newly-written .tmp files, causing EPERM.
+// Retry once to handle this flakiness.
+describe('download helpers', { retry: process.platform === 'win32' ? 2 : 0 }, () => {
+    it('resolves relative redirects against the original URL', () => {
+        expect(resolveRedirectUrl('https://example.com/a/file', '/cdn/file.bin')).toBe('https://example.com/cdn/file.bin');
+        expect(resolveRedirectUrl('https://example.com/a/file', '../next')).toBe('https://example.com/next');
+    });
+    it('formats browser cookies into a Cookie header', () => {
+        expect(formatCookieHeader([
+            { name: 'sid', value: 'abc', domain: 'example.com' },
+            { name: 'ct0', value: 'def', domain: 'example.com' },
+        ])).toBe('sid=abc; ct0=def');
+    });
+    it('fails after exceeding the redirect limit', async () => {
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 302;
+            res.setHeader('Location', '/loop');
+            res.end();
+        });
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
+        const destPath = path.join(tempDir, 'file.txt');
+        const result = await httpDownload(`${baseUrl}/loop`, destPath, { maxRedirects: 2 });
+        expect(result).toEqual({
+            success: false,
+            size: 0,
+            error: 'Too many redirects (> 2)',
+        });
+        expect(fs.existsSync(destPath)).toBe(false);
+    });
+    it('does not forward cookies across cross-domain redirects', async () => {
+        let forwardedCookie;
+        const targetUrl = await startServer((req, res) => {
+            forwardedCookie = req.headers.cookie;
+            res.statusCode = 200;
+            res.end('ok');
+        }, 'localhost');
+        const redirectUrl = await startServer((_req, res) => {
+            res.statusCode = 302;
+            res.setHeader('Location', targetUrl);
+            res.end();
+        });
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
+        const destPath = path.join(tempDir, 'redirect.txt');
+        const result = await httpDownload(`${redirectUrl}/start`, destPath, { cookies: 'sid=abc' });
+        expect(result).toEqual({ success: true, size: 2 });
+        expect(forwardedCookie).toBeUndefined();
+        expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+    });
+    it('does not forward cookie headers across cross-domain redirects', async () => {
+        let forwardedCookie;
+        const targetUrl = await startServer((req, res) => {
+            forwardedCookie = req.headers.cookie;
+            res.statusCode = 200;
+            res.end('ok');
+        }, 'localhost');
+        const redirectUrl = await startServer((_req, res) => {
+            res.statusCode = 302;
+            res.setHeader('Location', targetUrl);
+            res.end();
+        });
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
+        const destPath = path.join(tempDir, 'redirect-header.txt');
+        const result = await httpDownload(`${redirectUrl}/start`, destPath, {
+            headers: { Cookie: 'sid=header-cookie' },
+        });
+        expect(result).toEqual({ success: true, size: 2 });
+        expect(forwardedCookie).toBeUndefined();
+        expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+    });
+    it('bypasses proxy settings for loopback downloads', async () => {
+        vi.stubEnv('HTTP_PROXY', 'http://127.0.0.1:9');
+        const baseUrl = await startServer((_req, res) => {
+            res.statusCode = 200;
+            res.end('ok');
+        });
+        const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'opencli-dl-'));
+        tempDirs.push(tempDir);
+        const destPath = path.join(tempDir, 'loopback.txt');
+        const result = await httpDownload(`${baseUrl}/ok`, destPath);
+        expect(result).toEqual({ success: true, size: 2 });
+        expect(fs.readFileSync(destPath, 'utf8')).toBe('ok');
+    });
+});

package/vendor/opencli/dist/download/media-download.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Media download helper — shared logic for batch downloading images/videos.
+ *
+ * Used by: xiaohongshu/download, twitter/download, bilibili/download,
+ * and future media adapters.
+ *
+ * Flow: MediaItem[] → DownloadProgressTracker → httpDownload/ytdlpDownload → results
+ */
+import type { BrowserCookie } from '../types.js';
+export interface MediaItem {
+    type: 'image' | 'video' | 'video-tweet' | 'video-ytdlp';
+    url: string;
+    /** Optional custom filename (without directory) */
+    filename?: string;
+}
+export interface MediaDownloadOptions {
+    output: string;
+    /** Subdirectory inside output */
+    subdir?: string;
+    /** Cookie string for HTTP downloads */
+    cookies?: string;
+    /** Raw browser cookies — auto-exported to Netscape for yt-dlp, auto-cleaned up */
+    browserCookies?: BrowserCookie[];
+    /** Timeout in ms (default: 30000 for images, 60000 for videos) */
+    timeout?: number;
+    /** File name prefix (default: 'download') */
+    filenamePrefix?: string;
+    /** Extra yt-dlp args */
+    ytdlpExtraArgs?: string[];
+    /** Whether to show progress (default: true) */
+    verbose?: boolean;
+}
+export interface MediaDownloadResult {
+    index: number;
+    type: string;
+    status: string;
+    size: string;
+}
+/**
+ * Batch download media files with progress tracking.
+ *
+ * Handles:
+ * - DownloadProgressTracker for terminal UX
+ * - Automatic httpDownload vs ytdlpDownload routing via MediaItem.type
+ * - Cookie export to Netscape format for yt-dlp (auto-cleanup)
+ * - Directory creation
+ * - Error handling with per-file results
+ */
+export declare function downloadMedia(items: MediaItem[], options: MediaDownloadOptions): Promise<MediaDownloadResult[]>;

package/vendor/opencli/dist/download/media-download.js

@@ -0,0 +1,114 @@
+/**
+ * Media download helper — shared logic for batch downloading images/videos.
+ *
+ * Used by: xiaohongshu/download, twitter/download, bilibili/download,
+ * and future media adapters.
+ *
+ * Flow: MediaItem[] → DownloadProgressTracker → httpDownload/ytdlpDownload → results
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getErrorMessage } from '../errors.js';
+import { httpDownload, ytdlpDownload, checkYtdlp, getTempDir, exportCookiesToNetscape, } from './index.js';
+import { DownloadProgressTracker, formatBytes } from './progress.js';
+// ============================================================
+// Main API
+// ============================================================
+/**
+ * Batch download media files with progress tracking.
+ *
+ * Handles:
+ * - DownloadProgressTracker for terminal UX
+ * - Automatic httpDownload vs ytdlpDownload routing via MediaItem.type
+ * - Cookie export to Netscape format for yt-dlp (auto-cleanup)
+ * - Directory creation
+ * - Error handling with per-file results
+ */
+export async function downloadMedia(items, options) {
+    const { output, subdir, cookies, browserCookies, timeout, filenamePrefix = 'download', ytdlpExtraArgs = [], verbose = true, } = options;
+    if (!items || items.length === 0) {
+        return [{ index: 0, type: '-', status: 'failed', size: 'No media found' }];
+    }
+    // Create output directory
+    const outputDir = subdir ? path.join(output, subdir) : output;
+    fs.mkdirSync(outputDir, { recursive: true });
+    // Pre-check yt-dlp availability (once, not per-item)
+    const hasYtdlp = checkYtdlp();
+    // Auto-export browser cookies to Netscape format for yt-dlp
+    let cookiesFile;
+    const needsYtdlp = items.some(m => m.type === 'video-tweet' || m.type === 'video-ytdlp');
+    if (needsYtdlp && browserCookies && browserCookies.length > 0) {
+        const tempDir = getTempDir();
+        fs.mkdirSync(tempDir, { recursive: true });
+        cookiesFile = path.join(tempDir, `media_cookies_${Date.now()}.txt`);
+        exportCookiesToNetscape(browserCookies, cookiesFile);
+    }
+    const tracker = new DownloadProgressTracker(items.length, verbose);
+    const results = [];
+    try {
+        for (let i = 0; i < items.length; i++) {
+            const media = items[i];
+            const isVideo = media.type !== 'image';
+            const ext = isVideo ? 'mp4' : 'jpg';
+            const filename = media.filename || `${filenamePrefix}_${i + 1}.${ext}`;
+            const destPath = path.join(outputDir, filename);
+            const progressBar = tracker.onFileStart(filename, i);
+            try {
+                let result;
+                const useYtdlp = (media.type === 'video-tweet' || media.type === 'video-ytdlp') && hasYtdlp;
+                if (useYtdlp) {
+                    result = await ytdlpDownload(media.url, destPath, {
+                        cookiesFile,
+                        extraArgs: ytdlpExtraArgs,
+                        onProgress: (percent) => {
+                            if (progressBar)
+                                progressBar.update(percent, 100);
+                        },
+                    });
+                }
+                else {
+                    // Direct HTTP download for images and direct video URLs
+                    const dlTimeout = timeout || (isVideo ? 60000 : 30000);
+                    result = await httpDownload(media.url, destPath, {
+                        cookies,
+                        timeout: dlTimeout,
+                        onProgress: (received, total) => {
+                            if (progressBar)
+                                progressBar.update(received, total);
+                        },
+                    });
+                }
+                if (progressBar) {
+                    progressBar.complete(result.success, result.success ? formatBytes(result.size) : undefined);
+                }
+                tracker.onFileComplete(result.success);
+                results.push({
+                    index: i + 1,
+                    type: media.type === 'video-tweet' || media.type === 'video-ytdlp' ? 'video' : media.type,
+                    status: result.success ? 'success' : 'failed',
+                    size: result.success ? formatBytes(result.size) : (result.error || 'unknown error'),
+                });
+            }
+            catch (err) {
+                const msg = getErrorMessage(err);
+                if (progressBar)
+                    progressBar.fail(msg);
+                tracker.onFileComplete(false);
+                results.push({
+                    index: i + 1,
+                    type: media.type,
+                    status: 'failed',
+                    size: msg,
+                });
+            }
+        }
+    }
+    finally {
+        tracker.finish();
+        // Auto-cleanup exported cookies file
+        if (cookiesFile && fs.existsSync(cookiesFile)) {
+            fs.unlinkSync(cookiesFile);
+        }
+    }
+    return results;
+}

package/vendor/opencli/dist/download/progress.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Download progress display: terminal progress bars, status updates.
+ */
+export interface ProgressBar {
+    update(current: number, total: number, label?: string): void;
+    complete(success: boolean, message?: string): void;
+    fail(error: string): void;
+}
+/**
+ * Format bytes as human-readable string (KB, MB, GB).
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Format milliseconds as human-readable duration.
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Create a simple progress bar for terminal display.
+ */
+export declare function createProgressBar(filename: string, index: number, total: number): ProgressBar;
+/**
+ * Multi-file download progress tracker.
+ */
+export declare class DownloadProgressTracker {
+    private completed;
+    private failed;
+    private skipped;
+    private total;
+    private startTime;
+    private verbose;
+    constructor(total: number, verbose?: boolean);
+    onFileStart(filename: string, index: number): ProgressBar | null;
+    onFileComplete(success: boolean, skipped?: boolean): void;
+    getSummary(): string;
+    finish(): void;
+}

package/vendor/opencli/dist/download/progress.js

@@ -0,0 +1,111 @@
+/**
+ * Download progress display: terminal progress bars, status updates.
+ */
+import chalk from 'chalk';
+/**
+ * Format bytes as human-readable string (KB, MB, GB).
+ */
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}
+/**
+ * Format milliseconds as human-readable duration.
+ */
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/**
+ * Create a simple progress bar for terminal display.
+ */
+export function createProgressBar(filename, index, total) {
+    const prefix = chalk.dim(`[${index + 1}/${total}]`);
+    const truncatedName = filename.length > 40 ? filename.slice(0, 37) + '...' : filename;
+    return {
+        update(current, totalBytes, label) {
+            const percent = totalBytes > 0 ? Math.round((current / totalBytes) * 100) : 0;
+            const bar = createBar(percent);
+            const size = totalBytes > 0 ? formatBytes(totalBytes) : '';
+            const extra = label ? ` ${label}` : '';
+            process.stderr.write(`\r${prefix} ${truncatedName} ${bar} ${percent}% ${size}${extra}`);
+        },
+        complete(success, message) {
+            const icon = success ? chalk.green('✓') : chalk.red('✗');
+            const msg = message ? ` ${chalk.dim(message)}` : '';
+            process.stderr.write(`\r${prefix} ${icon} ${truncatedName}${msg}\n`);
+        },
+        fail(error) {
+            process.stderr.write(`\r${prefix} ${chalk.red('✗')} ${truncatedName} ${chalk.red(error)}\n`);
+        },
+    };
+}
+/**
+ * Create a progress bar string.
+ */
+function createBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    return chalk.cyan('█'.repeat(filled)) + chalk.dim('░'.repeat(empty));
+}
+/**
+ * Multi-file download progress tracker.
+ */
+export class DownloadProgressTracker {
+    completed = 0;
+    failed = 0;
+    skipped = 0;
+    total;
+    startTime;
+    verbose;
+    constructor(total, verbose = true) {
+        this.total = total;
+        this.startTime = Date.now();
+        this.verbose = verbose;
+    }
+    onFileStart(filename, index) {
+        if (!this.verbose)
+            return null;
+        return createProgressBar(filename, index, this.total);
+    }
+    onFileComplete(success, skipped = false) {
+        if (skipped) {
+            this.skipped++;
+        }
+        else if (success) {
+            this.completed++;
+        }
+        else {
+            this.failed++;
+        }
+    }
+    getSummary() {
+        const elapsed = formatDuration(Date.now() - this.startTime);
+        const parts = [];
+        if (this.completed > 0) {
+            parts.push(chalk.green(`${this.completed} downloaded`));
+        }
+        if (this.skipped > 0) {
+            parts.push(chalk.yellow(`${this.skipped} skipped`));
+        }
+        if (this.failed > 0) {
+            parts.push(chalk.red(`${this.failed} failed`));
+        }
+        return `${parts.join(', ')} in ${elapsed}`;
+    }
+    finish() {
+        if (this.verbose) {
+            process.stderr.write(`\n${chalk.bold('Download complete:')} ${this.getSummary()}\n`);
+        }
+    }
+}

package/vendor/opencli/dist/electron-apps.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Electron app registry — maps site names to launch metadata.
+ *
+ * Builtin apps are defined here. User-defined apps are loaded
+ * from ~/.opencli/apps.yaml (additive only, does not override builtins).
+ */
+export interface ElectronAppEntry {
+    /** CDP debug port (unique per app) */
+    port: number;
+    /** macOS process name for detection via pgrep */
+    processName: string;
+    /** Candidate executable names inside Contents/MacOS/, tried in order */
+    executableNames?: string[];
+    /** macOS bundle ID for path discovery */
+    bundleId?: string;
+    /** Human-readable name for prompts */
+    displayName?: string;
+    /** Additional launch args beyond --remote-debugging-port */
+    extraArgs?: string[];
+}
+export declare const builtinApps: Record<string, ElectronAppEntry>;
+/** Merge builtin + user-defined apps. User entries are additive only. */
+export declare function loadApps(userApps?: Record<string, Omit<ElectronAppEntry, 'displayName'> & {
+    displayName?: string;
+}>): Record<string, ElectronAppEntry>;
+export declare function getElectronApp(site: string): ElectronAppEntry | undefined;
+export declare function isElectronApp(site: string): boolean;
+/** Get all registered apps (builtin + user-defined). */
+export declare function getAllElectronApps(): Record<string, ElectronAppEntry>;
+/** Reset loaded apps (for testing). */
+export declare function _resetRegistry(): void;

package/vendor/opencli/dist/electron-apps.js

@@ -0,0 +1,71 @@
+/**
+ * Electron app registry — maps site names to launch metadata.
+ *
+ * Builtin apps are defined here. User-defined apps are loaded
+ * from ~/.opencli/apps.yaml (additive only, does not override builtins).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import yaml from 'js-yaml';
+export const builtinApps = {
+    cursor: { port: 9226, processName: 'Cursor', bundleId: 'com.todesktop.runtime.Cursor', displayName: 'Cursor' },
+    codex: { port: 9222, processName: 'Codex', bundleId: 'com.openai.codex', displayName: 'Codex' },
+    chatwise: { port: 9228, processName: 'ChatWise', bundleId: 'com.chatwise.app', displayName: 'ChatWise' },
+    notion: { port: 9230, processName: 'Notion', bundleId: 'notion.id', displayName: 'Notion' },
+    'discord-app': { port: 9232, processName: 'Discord', bundleId: 'com.discord.app', displayName: 'Discord' },
+    'doubao-app': { port: 9225, processName: 'Doubao', bundleId: 'com.volcengine.doubao', displayName: 'Doubao' },
+    antigravity: {
+        port: 9234,
+        processName: 'Antigravity',
+        executableNames: ['Electron', 'Antigravity'],
+        bundleId: 'dev.antigravity.app',
+        displayName: 'Antigravity',
+    },
+    chatgpt: { port: 9236, processName: 'ChatGPT', bundleId: 'com.openai.chat', displayName: 'ChatGPT' },
+};
+/** Merge builtin + user-defined apps. User entries are additive only. */
+export function loadApps(userApps) {
+    const merged = { ...builtinApps };
+    if (userApps) {
+        for (const [name, entry] of Object.entries(userApps)) {
+            if (!(name in merged)) {
+                merged[name] = entry;
+            }
+        }
+    }
+    return merged;
+}
+let _apps = null;
+function ensureLoaded() {
+    if (_apps)
+        return _apps;
+    let userApps;
+    try {
+        const yamlPath = path.join(os.homedir(), '.opencli', 'apps.yaml');
+        if (fs.existsSync(yamlPath)) {
+            const content = fs.readFileSync(yamlPath, 'utf-8');
+            const parsed = yaml.load(content);
+            userApps = parsed?.apps;
+        }
+    }
+    catch {
+        // Silently ignore malformed user config
+    }
+    _apps = loadApps(userApps);
+    return _apps;
+}
+export function getElectronApp(site) {
+    return ensureLoaded()[site];
+}
+export function isElectronApp(site) {
+    return site in ensureLoaded();
+}
+/** Get all registered apps (builtin + user-defined). */
+export function getAllElectronApps() {
+    return ensureLoaded();
+}
+/** Reset loaded apps (for testing). */
+export function _resetRegistry() {
+    _apps = null;
+}

package/vendor/opencli/dist/electron-apps.test.d.ts

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

package/vendor/opencli/dist/electron-apps.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { getElectronApp, isElectronApp, loadApps } from './electron-apps.js';
+describe('electron-apps registry', () => {
+    it('returns builtin app entry for cursor', () => {
+        const app = getElectronApp('cursor');
+        expect(app).toBeDefined();
+        expect(app.port).toBe(9226);
+        expect(app.processName).toBe('Cursor');
+    });
+    it('returns builtin app entry for codex', () => {
+        const app = getElectronApp('codex');
+        expect(app).toBeDefined();
+        expect(app.port).toBe(9222);
+    });
+    it('returns undefined for non-Electron sites', () => {
+        expect(getElectronApp('bilibili')).toBeUndefined();
+        expect(getElectronApp('hackernews')).toBeUndefined();
+    });
+    it('isElectronApp returns true for registered apps', () => {
+        expect(isElectronApp('cursor')).toBe(true);
+        expect(isElectronApp('codex')).toBe(true);
+        expect(isElectronApp('chatwise')).toBe(true);
+    });
+    it('isElectronApp returns false for non-Electron sites', () => {
+        expect(isElectronApp('bilibili')).toBe(false);
+        expect(isElectronApp('unknown-app')).toBe(false);
+    });
+    it('loadApps merges user config additively', () => {
+        const apps = loadApps({
+            myapp: { port: 9234, processName: 'MyApp' },
+        });
+        expect(apps.myapp).toBeDefined();
+        expect(apps.myapp.port).toBe(9234);
+        // Builtins still present
+        expect(apps.cursor).toBeDefined();
+    });
+    it('loadApps does not override builtin entries', () => {
+        const apps = loadApps({
+            cursor: { port: 9999, processName: 'FakeCursor' },
+        });
+        expect(apps.cursor.port).toBe(9226); // Builtin wins
+    });
+});

package/vendor/opencli/dist/engine.test.d.ts

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