@jackwener/opencli 0.9.6 → 1.0.0

package/dist/doctor.test.js

@@ -1,191 +1,51 @@
 import { describe, expect, it } from 'vitest';
-import { readTokenFromShellContent, renderBrowserDoctorReport, upsertShellToken, readTomlConfigToken, upsertTomlConfigToken, upsertJsonConfigToken, } from './doctor.js';
-describe('shell token helpers', () => {
-    it('reads token from shell export', () => {
-        expect(readTokenFromShellContent('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"\n')).toBe('abc123');
-    });
-    it('appends token export when missing', () => {
-        const next = upsertShellToken('export PATH="/usr/bin"\n', 'abc123');
-        expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"');
-    });
-    it('replaces token export when present', () => {
-        const next = upsertShellToken('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="old"\n', 'new');
-        expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="new"');
-        expect(next).not.toContain('"old"');
-    });
-});
-describe('toml token helpers', () => {
-    it('reads token from playwright env section', () => {
-        const content = `
-[mcp_servers.playwright.env]
-PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"
-`;
-        expect(readTomlConfigToken(content)).toBe('abc123');
-    });
-    it('updates token inside existing env section', () => {
-        const content = `
-[mcp_servers.playwright.env]
-PLAYWRIGHT_MCP_EXTENSION_TOKEN = "old"
-`;
-        const next = upsertTomlConfigToken(content, 'new');
-        expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "new"');
-        expect(next).not.toContain('"old"');
-    });
-    it('creates env section when missing', () => {
-        const content = `
-[mcp_servers.playwright]
-type = "stdio"
-`;
-        const next = upsertTomlConfigToken(content, 'abc123');
-        expect(next).toContain('[mcp_servers.playwright.env]');
-        expect(next).toContain('PLAYWRIGHT_MCP_EXTENSION_TOKEN = "abc123"');
-    });
-});
-describe('json token helpers', () => {
-    it('writes token into standard mcpServers config', () => {
-        const next = upsertJsonConfigToken(JSON.stringify({
-            mcpServers: {
-                playwright: {
-                    command: 'npx',
-                    args: ['-y', '@playwright/mcp@latest', '--extension'],
-                },
-            },
-        }), 'abc123');
-        const parsed = JSON.parse(next);
-        expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-    });
-    it('writes token into opencode mcp config', () => {
-        const next = upsertJsonConfigToken(JSON.stringify({
-            $schema: 'https://opencode.ai/config.json',
-            mcp: {
-                playwright: {
-                    command: ['npx', '-y', '@playwright/mcp@latest', '--extension'],
-                    enabled: true,
-                    type: 'local',
-                },
-            },
-        }), 'abc123');
-        const parsed = JSON.parse(next);
-        expect(parsed.mcp.playwright.environment.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-    });
-    it('creates standard mcpServers format for empty file (not OpenCode)', () => {
-        const next = upsertJsonConfigToken('', 'abc123');
-        const parsed = JSON.parse(next);
-        expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-        expect(parsed.mcp).toBeUndefined();
-    });
-    it('creates OpenCode format when filePath contains opencode', () => {
-        const next = upsertJsonConfigToken('', 'abc123', '/home/user/.config/opencode/opencode.json');
-        const parsed = JSON.parse(next);
-        expect(parsed.mcp.playwright.environment.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-        expect(parsed.mcpServers).toBeUndefined();
-    });
-    it('creates standard format when filePath is claude.json', () => {
-        const next = upsertJsonConfigToken('', 'abc123', '/home/user/.claude.json');
-        const parsed = JSON.parse(next);
-        expect(parsed.mcpServers.playwright.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN).toBe('abc123');
-    });
-});
-describe('fish shell support', () => {
-    it('generates fish set -gx syntax for fish config path', () => {
-        const next = upsertShellToken('', 'abc123', '/home/user/.config/fish/config.fish');
-        expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "abc123"');
-        expect(next).not.toContain('export');
-    });
-    it('replaces existing fish set line', () => {
-        const content = 'set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "old"\n';
-        const next = upsertShellToken(content, 'new', '/home/user/.config/fish/config.fish');
-        expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "new"');
-        expect(next).not.toContain('"old"');
-    });
-    it('appends fish syntax to existing fish config', () => {
-        const content = 'set -gx PATH /usr/bin\n';
-        const next = upsertShellToken(content, 'abc123', '/home/user/.config/fish/config.fish');
-        expect(next).toContain('set -gx PLAYWRIGHT_MCP_EXTENSION_TOKEN "abc123"');
-        expect(next).toContain('set -gx PATH /usr/bin');
-    });
-    it('uses export syntax for zshrc even with filePath', () => {
-        const next = upsertShellToken('', 'abc123', '/home/user/.zshrc');
-        expect(next).toContain('export PLAYWRIGHT_MCP_EXTENSION_TOKEN="abc123"');
-        expect(next).not.toContain('set -gx');
-    });
-});
+import { renderBrowserDoctorReport } from './doctor.js';
 describe('doctor report rendering', () => {
     const strip = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
-    it('renders OK-style report when tokens match', () => {
+    it('renders OK-style report when daemon and extension connected', () => {
         const text = strip(renderBrowserDoctorReport({
-            envToken: 'abc123',
-            envFingerprint: 'fp1',
-            extensionToken: 'abc123',
-            extensionFingerprint: 'fp1',
-            extensionInstalled: true,
-            extensionBrowsers: ['Chrome'],
-            shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'abc123', fingerprint: 'fp1' }],
-            configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
-            recommendedToken: 'abc123',
-            recommendedFingerprint: 'fp1',
-            warnings: [],
+            daemonRunning: true,
+            extensionConnected: true,
             issues: [],
         }));
-        expect(text).toContain('[OK] Extension installed (Chrome)');
-        expect(text).toContain('[OK] Environment token: configured (fp1)');
-        expect(text).toContain('[OK] /tmp/mcp.json');
-        expect(text).toContain('configured (fp1)');
+        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('[OK] Extension: connected');
+        expect(text).toContain('Everything looks good!');
+    });
+    it('renders MISSING when daemon not running', () => {
+        const text = strip(renderBrowserDoctorReport({
+            daemonRunning: false,
+            extensionConnected: false,
+            issues: ['Daemon is not running.'],
+        }));
+        expect(text).toContain('[MISSING] Daemon: not running');
+        expect(text).toContain('[MISSING] Extension: not connected');
+        expect(text).toContain('Daemon is not running.');
     });
-    it('renders MISMATCH-style report when fingerprints differ', () => {
+    it('renders extension not connected when daemon is running', () => {
         const text = strip(renderBrowserDoctorReport({
-            envToken: 'abc123',
-            envFingerprint: 'fp1',
-            extensionToken: null,
-            extensionFingerprint: null,
-            extensionInstalled: false,
-            extensionBrowsers: [],
-            shellFiles: [{ path: '/tmp/.zshrc', exists: true, token: 'def456', fingerprint: 'fp2' }],
-            configs: [{ path: '/tmp/mcp.json', exists: true, format: 'json', token: 'abc123', fingerprint: 'fp1', writable: true }],
-            recommendedToken: 'abc123',
-            recommendedFingerprint: 'fp1',
-            warnings: [],
-            issues: ['Detected inconsistent Playwright MCP tokens across env/config files.'],
+            daemonRunning: true,
+            extensionConnected: false,
+            issues: ['Daemon is running but the Chrome extension is not connected.'],
         }));
-        expect(text).toContain('[MISSING] Extension not installed in any browser');
-        expect(text).toContain('[MISMATCH] Environment token: configured (fp1)');
-        expect(text).toContain('[MISMATCH] /tmp/.zshrc');
-        expect(text).toContain('configured (fp2)');
-        expect(text).toContain('[MISMATCH] Recommended token fingerprint: fp1');
+        expect(text).toContain('[OK] Daemon: running on port 19825');
+        expect(text).toContain('[MISSING] Extension: not connected');
     });
     it('renders connectivity OK when live test succeeds', () => {
         const text = strip(renderBrowserDoctorReport({
-            envToken: 'abc123',
-            envFingerprint: 'fp1',
-            extensionToken: 'abc123',
-            extensionFingerprint: 'fp1',
-            extensionInstalled: true,
-            extensionBrowsers: ['Chrome'],
-            shellFiles: [],
-            configs: [],
-            recommendedToken: 'abc123',
-            recommendedFingerprint: 'fp1',
+            daemonRunning: true,
+            extensionConnected: true,
             connectivity: { ok: true, durationMs: 1234 },
-            warnings: [],
             issues: [],
         }));
-        expect(text).toContain('[OK] Browser connectivity: connected in 1.2s');
+        expect(text).toContain('[OK] Connectivity: connected in 1.2s');
     });
-    it('renders connectivity WARN when not tested', () => {
+    it('renders connectivity SKIP when not tested', () => {
         const text = strip(renderBrowserDoctorReport({
-            envToken: 'abc123',
-            envFingerprint: 'fp1',
-            extensionToken: 'abc123',
-            extensionFingerprint: 'fp1',
-            extensionInstalled: true,
-            extensionBrowsers: ['Chrome'],
-            shellFiles: [],
-            configs: [],
-            recommendedToken: 'abc123',
-            recommendedFingerprint: 'fp1',
-            warnings: [],
+            daemonRunning: true,
+            extensionConnected: true,
             issues: [],
         }));
-        expect(text).toContain('[WARN] Browser connectivity: not tested (use --live)');
+        expect(text).toContain('[SKIP] Connectivity: not tested (use --live)');
     });
 });

package/dist/download/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Download utilities: HTTP downloads, yt-dlp wrapper, format conversion.
+ */
+export interface DownloadOptions {
+    cookies?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    onProgress?: (received: number, total: number) => void;
+}
+export interface YtdlpOptions {
+    cookies?: string;
+    cookiesFile?: string;
+    format?: string;
+    extraArgs?: string[];
+    onProgress?: (percent: number) => void;
+}
+/**
+ * Check if yt-dlp is available in PATH.
+ */
+export declare function checkYtdlp(): boolean;
+/**
+ * Check if ffmpeg is available in PATH.
+ */
+export declare function checkFfmpeg(): boolean;
+/**
+ * Detect content type from URL and optional headers.
+ */
+export declare function detectContentType(url: string, contentType?: string): 'image' | 'video' | 'document' | 'binary';
+/**
+ * Check if URL requires yt-dlp for download.
+ */
+export declare function requiresYtdlp(url: string): boolean;
+/**
+ * HTTP download with progress callback.
+ */
+export declare function httpDownload(url: string, destPath: string, options?: DownloadOptions): Promise<{
+    success: boolean;
+    size: number;
+    error?: string;
+}>;
+/**
+ * Export cookies to Netscape format for yt-dlp.
+ */
+export declare function exportCookiesToNetscape(cookies: Array<{
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+}>, filePath: string): void;
+/**
+ * Download video using yt-dlp.
+ */
+export declare function ytdlpDownload(url: string, destPath: string, options?: YtdlpOptions): Promise<{
+    success: boolean;
+    size: number;
+    error?: string;
+}>;
+/**
+ * Save document content to file.
+ */
+export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, any>): Promise<{
+    success: boolean;
+    size: number;
+    error?: string;
+}>;
+/**
+ * Sanitize filename by removing invalid characters.
+ */
+export declare function sanitizeFilename(name: string, maxLength?: number): string;
+/**
+ * Generate filename from URL if not provided.
+ */
+export declare function generateFilename(url: string, index: number, extension?: string): string;
+/**
+ * Get temp directory for cookie files.
+ */
+export declare function getTempDir(): string;

package/dist/download/index.js

@@ -0,0 +1,325 @@
+/**
+ * Download utilities: HTTP downloads, yt-dlp wrapper, format conversion.
+ */
+import { spawn, execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as https from 'node:https';
+import * as http from 'node:http';
+import * as os from 'node:os';
+import { URL } from 'node:url';
+/**
+ * Check if yt-dlp is available in PATH.
+ */
+export function checkYtdlp() {
+    try {
+        execSync('yt-dlp --version', { encoding: 'utf-8', stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if ffmpeg is available in PATH.
+ */
+export function checkFfmpeg() {
+    try {
+        execSync('ffmpeg -version', { encoding: 'utf-8', stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect content type from URL and optional headers.
+ */
+export function detectContentType(url, contentType) {
+    // Check content-type header first
+    if (contentType) {
+        if (contentType.startsWith('image/'))
+            return 'image';
+        if (contentType.startsWith('video/'))
+            return 'video';
+        if (contentType.startsWith('text/') || contentType.includes('json') || contentType.includes('xml'))
+            return 'document';
+    }
+    // Detect from URL
+    const urlLower = url.toLowerCase();
+    const ext = path.extname(new URL(url).pathname).toLowerCase();
+    // Image extensions
+    if (['.jpg', '.jpeg', '.png', '.gif', '.webp', '.svg', '.ico', '.bmp', '.avif'].includes(ext)) {
+        return 'image';
+    }
+    // Video extensions
+    if (['.mp4', '.webm', '.avi', '.mov', '.mkv', '.flv', '.m3u8', '.ts'].includes(ext)) {
+        return 'video';
+    }
+    // Video platforms (need yt-dlp)
+    if (urlLower.includes('youtube.com') || urlLower.includes('youtu.be') ||
+        urlLower.includes('bilibili.com') || urlLower.includes('twitter.com') ||
+        urlLower.includes('x.com') || urlLower.includes('tiktok.com') ||
+        urlLower.includes('vimeo.com') || urlLower.includes('twitch.tv')) {
+        return 'video';
+    }
+    // Document extensions
+    if (['.html', '.htm', '.json', '.xml', '.txt', '.md', '.markdown'].includes(ext)) {
+        return 'document';
+    }
+    return 'binary';
+}
+/**
+ * Check if URL requires yt-dlp for download.
+ */
+export function requiresYtdlp(url) {
+    const urlLower = url.toLowerCase();
+    return (urlLower.includes('youtube.com') ||
+        urlLower.includes('youtu.be') ||
+        urlLower.includes('bilibili.com/video') ||
+        urlLower.includes('twitter.com') ||
+        urlLower.includes('x.com') ||
+        urlLower.includes('tiktok.com') ||
+        urlLower.includes('vimeo.com') ||
+        urlLower.includes('twitch.tv'));
+}
+/**
+ * HTTP download with progress callback.
+ */
+export async function httpDownload(url, destPath, options = {}) {
+    const { cookies, headers = {}, timeout = 30000, onProgress } = options;
+    return new Promise((resolve) => {
+        const parsedUrl = new URL(url);
+        const protocol = parsedUrl.protocol === 'https:' ? https : http;
+        const requestHeaders = {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            ...headers,
+        };
+        if (cookies) {
+            requestHeaders['Cookie'] = cookies;
+        }
+        // Ensure directory exists
+        const dir = path.dirname(destPath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tempPath = `${destPath}.tmp`;
+        const file = fs.createWriteStream(tempPath);
+        const request = protocol.get(url, { headers: requestHeaders, timeout }, (response) => {
+            // Handle redirects
+            if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+                file.close();
+                fs.unlinkSync(tempPath);
+                httpDownload(response.headers.location, destPath, options).then(resolve);
+                return;
+            }
+            if (response.statusCode !== 200) {
+                file.close();
+                fs.unlinkSync(tempPath);
+                resolve({ success: false, size: 0, error: `HTTP ${response.statusCode}` });
+                return;
+            }
+            const totalSize = parseInt(response.headers['content-length'] || '0', 10);
+            let received = 0;
+            response.on('data', (chunk) => {
+                received += chunk.length;
+                if (onProgress)
+                    onProgress(received, totalSize);
+            });
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                // Rename temp file to final destination
+                fs.renameSync(tempPath, destPath);
+                resolve({ success: true, size: received });
+            });
+        });
+        request.on('error', (err) => {
+            file.close();
+            if (fs.existsSync(tempPath))
+                fs.unlinkSync(tempPath);
+            resolve({ success: false, size: 0, error: err.message });
+        });
+        request.on('timeout', () => {
+            request.destroy();
+            file.close();
+            if (fs.existsSync(tempPath))
+                fs.unlinkSync(tempPath);
+            resolve({ success: false, size: 0, error: 'Timeout' });
+        });
+    });
+}
+/**
+ * Export cookies to Netscape format for yt-dlp.
+ */
+export function exportCookiesToNetscape(cookies, filePath) {
+    const lines = [
+        '# Netscape HTTP Cookie File',
+        '# https://curl.se/docs/http-cookies.html',
+        '# This is a generated file!  Do not edit.',
+        '',
+    ];
+    for (const cookie of cookies) {
+        const domain = cookie.domain.startsWith('.') ? cookie.domain : `.${cookie.domain}`;
+        const includeSubdomains = 'TRUE';
+        const cookiePath = cookie.path || '/';
+        const secure = cookie.secure ? 'TRUE' : 'FALSE';
+        const expiry = Math.floor(Date.now() / 1000) + 86400 * 365; // 1 year from now
+        lines.push(`${domain}\t${includeSubdomains}\t${cookiePath}\t${secure}\t${expiry}\t${cookie.name}\t${cookie.value}`);
+    }
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, lines.join('\n'));
+}
+/**
+ * Download video using yt-dlp.
+ */
+export async function ytdlpDownload(url, destPath, options = {}) {
+    const { cookiesFile, format = 'best', extraArgs = [], onProgress } = options;
+    if (!checkYtdlp()) {
+        return { success: false, size: 0, error: 'yt-dlp not installed. Install with: pip install yt-dlp' };
+    }
+    return new Promise((resolve) => {
+        const dir = path.dirname(destPath);
+        fs.mkdirSync(dir, { recursive: true });
+        // Build yt-dlp arguments
+        const args = [
+            url,
+            '-o', destPath,
+            '-f', format,
+            '--no-playlist',
+            '--progress',
+        ];
+        if (cookiesFile && fs.existsSync(cookiesFile)) {
+            args.push('--cookies', cookiesFile);
+        }
+        else {
+            // Try to use browser cookies
+            args.push('--cookies-from-browser', 'chrome');
+        }
+        args.push(...extraArgs);
+        const proc = spawn('yt-dlp', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let lastPercent = 0;
+        let errorOutput = '';
+        proc.stderr.on('data', (data) => {
+            const line = data.toString();
+            errorOutput += line;
+            // Parse progress from yt-dlp output
+            const match = line.match(/(\d+\.?\d*)%/);
+            if (match && onProgress) {
+                const percent = parseFloat(match[1]);
+                if (percent > lastPercent) {
+                    lastPercent = percent;
+                    onProgress(percent);
+                }
+            }
+        });
+        proc.stdout.on('data', (data) => {
+            const line = data.toString();
+            const match = line.match(/(\d+\.?\d*)%/);
+            if (match && onProgress) {
+                const percent = parseFloat(match[1]);
+                if (percent > lastPercent) {
+                    lastPercent = percent;
+                    onProgress(percent);
+                }
+            }
+        });
+        proc.on('close', (code) => {
+            if (code === 0 && fs.existsSync(destPath)) {
+                const stats = fs.statSync(destPath);
+                resolve({ success: true, size: stats.size });
+            }
+            else {
+                // Check for common yt-dlp output patterns
+                const patterns = fs.readdirSync(dir).filter(f => f.startsWith(path.basename(destPath, path.extname(destPath))));
+                if (patterns.length > 0) {
+                    const actualFile = path.join(dir, patterns[0]);
+                    const stats = fs.statSync(actualFile);
+                    resolve({ success: true, size: stats.size });
+                }
+                else {
+                    resolve({ success: false, size: 0, error: errorOutput.slice(0, 200) || `Exit code ${code}` });
+                }
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, size: 0, error: err.message });
+        });
+    });
+}
+/**
+ * Save document content to file.
+ */
+export async function saveDocument(content, destPath, format = 'markdown', metadata) {
+    try {
+        const dir = path.dirname(destPath);
+        fs.mkdirSync(dir, { recursive: true });
+        let output;
+        if (format === 'json') {
+            output = JSON.stringify({ ...metadata, content }, null, 2);
+        }
+        else if (format === 'markdown') {
+            // Add frontmatter if metadata exists
+            const frontmatter = metadata ? `---\n${Object.entries(metadata).map(([k, v]) => `${k}: ${JSON.stringify(v)}`).join('\n')}\n---\n\n` : '';
+            output = frontmatter + content;
+        }
+        else {
+            output = content;
+        }
+        fs.writeFileSync(destPath, output, 'utf-8');
+        return { success: true, size: Buffer.byteLength(output, 'utf-8') };
+    }
+    catch (err) {
+        return { success: false, size: 0, error: err.message };
+    }
+}
+/**
+ * Sanitize filename by removing invalid characters.
+ */
+export function sanitizeFilename(name, maxLength = 200) {
+    return name
+        .replace(/[<>:"/\\|?*\x00-\x1f]/g, '_') // Remove invalid chars
+        .replace(/\s+/g, '_') // Replace spaces with underscores
+        .replace(/_+/g, '_') // Collapse multiple underscores
+        .replace(/^_|_$/g, '') // Trim underscores
+        .slice(0, maxLength);
+}
+/**
+ * Generate filename from URL if not provided.
+ */
+export function generateFilename(url, index, extension) {
+    try {
+        const parsedUrl = new URL(url);
+        const pathname = parsedUrl.pathname;
+        const basename = path.basename(pathname);
+        if (basename && basename !== '/' && basename.includes('.')) {
+            return sanitizeFilename(basename);
+        }
+        // Generate from hostname and index
+        const ext = extension || detectExtension(url);
+        const hostname = parsedUrl.hostname.replace(/^www\./, '');
+        return sanitizeFilename(`${hostname}_${index + 1}${ext}`);
+    }
+    catch {
+        const ext = extension || '.bin';
+        return `download_${index + 1}${ext}`;
+    }
+}
+/**
+ * Detect file extension from URL.
+ */
+function detectExtension(url) {
+    const type = detectContentType(url);
+    switch (type) {
+        case 'image': return '.jpg';
+        case 'video': return '.mp4';
+        case 'document': return '.md';
+        default: return '.bin';
+    }
+}
+/**
+ * Get temp directory for cookie files.
+ */
+export function getTempDir() {
+    return path.join(os.tmpdir(), 'opencli-download');
+}

package/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;
+}