blyuecode 0.7.2 → 0.8.3

package/dist/core/ytdlp.js

@@ -0,0 +1,211 @@
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const execAsync = promisify(exec);
+const LOG_DIR = path.join(os.homedir(), '.blyue', 'log');
+const LOG_FILE = path.join(LOG_DIR, 'ytdlp.log');
+function log(line) {
+    try {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+        fs.appendFileSync(LOG_FILE, `${new Date().toISOString()} ${line}\n`, 'utf8');
+    }
+    catch { }
+}
+export function ytdlpLogPath() {
+    return LOG_FILE;
+}
+export function readYtdlpLog(limit = 100) {
+    if (!fs.existsSync(LOG_FILE))
+        return [];
+    try {
+        const lines = fs.readFileSync(LOG_FILE, 'utf8').split('\n').filter(Boolean);
+        return lines.slice(-limit);
+    }
+    catch {
+        return [];
+    }
+}
+function classify(stderr, exitCode) {
+    const s = stderr.toLowerCase();
+    const tail = stderr.split('\n').slice(-4).join(' | ').slice(0, 300);
+    if (s.includes('temporary failure in name resolution') ||
+        s.includes('network is unreachable') ||
+        s.includes('connection refused') ||
+        s.includes('failed to resolve') ||
+        s.includes('no address associated') ||
+        s.includes('connection timed out')) {
+        return {
+            kind: 'network',
+            userMessage: 'no network — check your connection and try again',
+            detail: tail,
+            autoFixable: false,
+        };
+    }
+    if (s.includes('403') || s.includes('forbidden')) {
+        return {
+            kind: 'forbidden',
+            userMessage: 'yt-dlp blocked (HTTP 403) — usually a stale yt-dlp version',
+            detail: tail,
+            autoFixable: true,
+        };
+    }
+    if (s.includes('429') || s.includes('too many requests')) {
+        return {
+            kind: 'ratelimit',
+            userMessage: 'rate limited by youtube — wait a minute and retry',
+            detail: tail,
+            autoFixable: false,
+        };
+    }
+    if (s.includes('video unavailable') || s.includes('private video') || s.includes('removed')) {
+        return {
+            kind: 'notfound',
+            userMessage: 'video is unavailable, private, or removed',
+            detail: tail,
+            autoFixable: false,
+        };
+    }
+    if (s.includes('not available in your country') || s.includes('geo')) {
+        return {
+            kind: 'geo',
+            userMessage: 'video is geo-blocked in your region',
+            detail: tail,
+            autoFixable: false,
+        };
+    }
+    if (s.includes('no space left')) {
+        return {
+            kind: 'disk',
+            userMessage: 'out of disk space',
+            detail: tail,
+            autoFixable: false,
+        };
+    }
+    return {
+        kind: 'unknown',
+        userMessage: `yt-dlp failed (exit ${exitCode}): ${tail || 'no output'}`,
+        detail: tail,
+        autoFixable: false,
+    };
+}
+export async function runYtdlp(args, opts = {}) {
+    const cmd = 'yt-dlp ' + args.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(' ');
+    const started = Date.now();
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            maxBuffer: 20 * 1024 * 1024,
+            timeout: opts.timeoutMs ?? 15 * 60 * 1000,
+        });
+        log(`OK  ${Date.now() - started}ms  ${cmd.slice(0, 200)}`);
+        return { ok: true, stdout, stderr };
+    }
+    catch (err) {
+        const stderr = (err.stderr || '') + (err.stdout ? '\n' + err.stdout : '');
+        const code = err.code ?? 1;
+        const classified = classify(stderr || String(err), code);
+        log(`ERR ${Date.now() - started}ms kind=${classified.kind} code=${code}  ` +
+            `cmd=${cmd.slice(0, 200)}  detail=${classified.detail}`);
+        return { ok: false, stdout: err.stdout || '', stderr, error: classified };
+    }
+}
+export async function runYtdlpStream(args, onProgress, opts = {}) {
+    const fullArgs = [...args, '--newline', '--progress'];
+    const cmd = 'yt-dlp ' + fullArgs.map((a) => `"${a.replace(/"/g, '\\"')}"`).join(' ');
+    const started = Date.now();
+    return new Promise((resolve) => {
+        const proc = spawn('yt-dlp', fullArgs, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        const onData = (chunk, toStdout) => {
+            const text = chunk.toString('utf8');
+            if (toStdout)
+                stdout += text;
+            else
+                stderr += text;
+            if (onProgress) {
+                for (const line of text.split(/[\r\n]+/)) {
+                    const t = line.trim();
+                    if (t)
+                        onProgress(t);
+                }
+            }
+        };
+        proc.stdout?.on('data', (c) => onData(c, true));
+        proc.stderr?.on('data', (c) => onData(c, false));
+        const timeout = opts.timeoutMs ?? 30 * 60 * 1000;
+        const timer = setTimeout(() => {
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { }
+            log(`TIMEOUT ${Date.now() - started}ms  ${cmd.slice(0, 200)}`);
+            resolve({
+                ok: false, stdout, stderr,
+                error: { kind: 'unknown', userMessage: 'download timed out', detail: '', autoFixable: false },
+            });
+        }, timeout);
+        proc.on('exit', (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                log(`OK  ${Date.now() - started}ms  ${cmd.slice(0, 200)}`);
+                resolve({ ok: true, stdout, stderr });
+            }
+            else {
+                const combined = stderr || stdout;
+                const classified = classify(combined, code ?? 1);
+                log(`ERR ${Date.now() - started}ms kind=${classified.kind} code=${code}  detail=${classified.detail}`);
+                resolve({ ok: false, stdout, stderr, error: classified });
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            resolve({
+                ok: false, stdout, stderr,
+                error: { kind: 'unknown', userMessage: err.message, detail: String(err), autoFixable: false },
+            });
+        });
+    });
+}
+export function updateCmd() {
+    const isTermux = !!process.env.TERMUX_VERSION || !!process.env.PREFIX?.includes('com.termux');
+    if (isTermux)
+        return 'pkg upgrade -y yt-dlp';
+    const p = os.platform();
+    if (p === 'linux')
+        return 'sudo apt install --only-upgrade -y yt-dlp || pip install --upgrade yt-dlp';
+    if (p === 'darwin')
+        return 'brew upgrade yt-dlp';
+    if (p === 'win32')
+        return 'winget upgrade yt-dlp.yt-dlp';
+    return null;
+}
+export async function updateYtdlp() {
+    const cmd = updateCmd();
+    if (!cmd)
+        return { ok: false, output: 'no update command for this platform' };
+    log(`UPDATE  ${cmd}`);
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: 5 * 60 * 1000,
+        });
+        log(`UPDATE OK  ${(stdout + stderr).slice(-300)}`);
+        return { ok: true, output: (stdout + stderr).slice(-1000) };
+    }
+    catch (err) {
+        const out = (err.stderr || '') + (err.stdout || '') + (err.message || '');
+        log(`UPDATE ERR  ${out.slice(-300)}`);
+        return { ok: false, output: out.slice(-1000) };
+    }
+}
+export async function ytdlpVersion() {
+    try {
+        const { stdout } = await execAsync('yt-dlp --version');
+        return stdout.trim();
+    }
+    catch {
+        return 'not installed';
+    }
+}