blyuecode 0.7.1 → 0.8.0

package/dist/core/deps.js

@@ -0,0 +1,99 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+const execAsync = promisify(exec);
+export const MEDIA_DEPS = [
+    { name: 'yt-dlp', role: 'search + download' },
+    { name: 'ffmpeg', role: 'extract audio, merge video' },
+    { name: 'mpv', role: 'playback' },
+];
+export function detectPlatform() {
+    const isTermux = !!process.env.TERMUX_VERSION ||
+        !!process.env.PREFIX?.includes('com.termux');
+    if (isTermux) {
+        return {
+            os: 'termux',
+            installCmd: 'pkg install -y yt-dlp ffmpeg mpv',
+            updateHint: 'Termux packages (native ARM builds)',
+            approximateSizeMb: 180,
+        };
+    }
+    const p = os.platform();
+    if (p === 'linux') {
+        return {
+            os: 'linux',
+            installCmd: 'sudo apt install -y yt-dlp ffmpeg mpv',
+            updateHint: 'apt (Debian/Ubuntu/MX)',
+            approximateSizeMb: 220,
+        };
+    }
+    if (p === 'darwin') {
+        return {
+            os: 'darwin',
+            installCmd: 'brew install yt-dlp ffmpeg mpv',
+            updateHint: 'Homebrew',
+            approximateSizeMb: 250,
+        };
+    }
+    if (p === 'win32') {
+        return {
+            os: 'win32',
+            installCmd: 'winget install yt-dlp.yt-dlp Gyan.FFmpeg mpv.net',
+            updateHint: 'winget',
+            approximateSizeMb: 260,
+        };
+    }
+    return {
+        os: 'unknown',
+        installCmd: null,
+        updateHint: 'install yt-dlp, ffmpeg, mpv manually',
+        approximateSizeMb: 0,
+    };
+}
+export async function hasBinary(name) {
+    try {
+        await execAsync(`command -v ${name}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkMediaDeps() {
+    const results = await Promise.all(MEDIA_DEPS.map(async (d) => ({ name: d.name, ok: await hasBinary(d.name) })));
+    const missing = results.filter((r) => !r.ok).map((r) => r.name);
+    const present = results.filter((r) => r.ok).map((r) => r.name);
+    return {
+        missing,
+        present,
+        allPresent: missing.length === 0,
+        platform: detectPlatform(),
+    };
+}
+export async function installMediaDeps(onOutput) {
+    const platform = detectPlatform();
+    const cmd = platform.installCmd;
+    if (!cmd) {
+        return { ok: false, output: 'no install command for this platform' };
+    }
+    return new Promise((resolve) => {
+        const proc = exec(cmd, { maxBuffer: 10 * 1024 * 1024 });
+        let buf = '';
+        proc.stdout?.on('data', (c) => {
+            const s = c.toString();
+            buf += s;
+            onOutput?.(s);
+        });
+        proc.stderr?.on('data', (c) => {
+            const s = c.toString();
+            buf += s;
+            onOutput?.(s);
+        });
+        proc.on('exit', (code) => {
+            resolve({ ok: code === 0, output: buf.slice(-2000) });
+        });
+        proc.on('error', (err) => {
+            resolve({ ok: false, output: err.message });
+        });
+    });
+}

package/dist/core/image.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const API = 'https://api.replicate.com/v1';
+const MODEL = 'black-forest-labs/flux-schnell';
+const IMAGES_DIR = path.join(os.homedir(), '.blyue', 'images');
+function apiKey() {
+    const k = process.env.REPLICATE_API_KEY || process.env.IMAGE_API_KEY;
+    if (!k) {
+        throw new Error('No image API key. Set REPLICATE_API_KEY in ~/.blyue/.env — get one at replicate.com/account/api-tokens');
+    }
+    return k;
+}
+async function predict(prompt) {
+    const res = await fetch(`${API}/models/${MODEL}/predictions`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey()}`,
+            'Content-Type': 'application/json',
+            Prefer: 'wait=60',
+        },
+        body: JSON.stringify({
+            input: { prompt, num_outputs: 1, aspect_ratio: '1:1', output_format: 'png' },
+        }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Replicate ${res.status}: ${text.slice(0, 200)}`);
+    }
+    return (await res.json());
+}
+async function poll(id, timeoutMs = 120_000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const res = await fetch(`${API}/predictions/${id}`, {
+            headers: { Authorization: `Bearer ${apiKey()}` },
+        });
+        const p = (await res.json());
+        if (p.status === 'succeeded' || p.status === 'failed' || p.status === 'canceled') {
+            return p;
+        }
+        await new Promise((r) => setTimeout(r, 1500));
+    }
+    throw new Error('image generation timed out after 120s');
+}
+export async function generateImage(prompt) {
+    if (!prompt.trim())
+        throw new Error('empty prompt');
+    let p = await predict(prompt);
+    if (p.status === 'starting' || p.status === 'processing')
+        p = await poll(p.id);
+    if (p.status !== 'succeeded' || !p.output) {
+        throw new Error(`generation failed: ${p.error || p.status}`);
+    }
+    const url = Array.isArray(p.output) ? p.output[0] : p.output;
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`download failed: HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    fs.mkdirSync(IMAGES_DIR, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const slug = prompt.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 40);
+    const file = path.join(IMAGES_DIR, `${stamp}-${slug}.png`);
+    fs.writeFileSync(file, buf);
+    return { path: file, url, prompt };
+}
+export function imagesDir() {
+    return IMAGES_DIR;
+}

package/dist/core/media.js

@@ -0,0 +1,210 @@
+import { exec } from 'child_process';
+import { runYtdlp } from './ytdlp.js';
+import { promisify } from 'util';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+const execAsync = promisify(exec);
+const MUSIC_DIR = path.join(os.homedir(), '.blyue', 'music');
+const VIDEO_DIR = path.join(os.homedir(), '.blyue', 'video');
+export function musicDir() { return MUSIC_DIR; }
+export function videoDir() { return VIDEO_DIR; }
+export function keepMedia() {
+    return process.env.BLYUE_KEEP_MEDIA === '1';
+}
+export async function hasBinary(name) {
+    try {
+        await execAsync(`command -v ${name}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkDeps() {
+    const [ytdlp, ffmpeg, mpv] = await Promise.all([
+        hasBinary('yt-dlp'), hasBinary('ffmpeg'), hasBinary('mpv'),
+    ]);
+    const missing = [];
+    if (!ytdlp)
+        missing.push('yt-dlp');
+    if (!ffmpeg)
+        missing.push('ffmpeg');
+    if (!mpv)
+        missing.push('mpv');
+    return { ytdlp, ffmpeg, mpv, ok: missing.length === 0, missing };
+}
+export async function searchYouTubeN(query, n = 5) {
+    const r = await runYtdlp([
+        'ytsearch' + n + ':' + query,
+        '--dump-json',
+        '--no-warnings',
+        '--skip-download',
+        '--default-search', 'ytsearch' + n,
+    ]);
+    if (!r.ok) {
+        throw new Error(r.error?.userMessage || 'yt-dlp search failed');
+    }
+    const lines = r.stdout.trim().split('\n').filter(Boolean);
+    const out = [];
+    for (const line of lines) {
+        try {
+            const info = JSON.parse(line);
+            if (!info.id)
+                continue;
+            out.push({
+                id: String(info.id),
+                title: String(info.title || 'unknown'),
+                duration: Number(info.duration) || 0,
+                uploader: String(info.uploader || info.channel || ''),
+                kind: 'audio',
+            });
+        }
+        catch { }
+    }
+    return out;
+}
+export async function searchYouTube(query) {
+    const r = await runYtdlp([
+        'ytsearch1:' + query,
+        '--dump-json',
+        '--no-warnings',
+        '--skip-download',
+        '--default-search', 'ytsearch1',
+    ]);
+    if (!r.ok) {
+        throw new Error(r.error?.userMessage || 'yt-dlp search failed');
+    }
+    const first = r.stdout.trim().split('\n')[0];
+    if (!first)
+        throw new Error('no results');
+    let info;
+    try {
+        info = JSON.parse(first);
+    }
+    catch (err) {
+        throw new Error('could not parse yt-dlp output: ' + err.message);
+    }
+    return {
+        id: String(info.id || ''),
+        title: String(info.title || 'unknown'),
+        duration: Number(info.duration) || 0,
+        uploader: String(info.uploader || info.channel || ''),
+        kind: 'audio',
+    };
+}
+export async function downloadAudio(track, onProgress) {
+    fs.mkdirSync(MUSIC_DIR, { recursive: true });
+    const outTemplate = path.join(MUSIC_DIR, '%(id)s.%(ext)s');
+    onProgress?.({ phase: 'downloading' });
+    const r = await runYtdlp([
+        '-f', 'bestaudio[ext=m4a]/bestaudio[ext=webm]/bestaudio/best',
+        '--no-part',
+        '--no-mtime',
+        '--no-cache-dir',
+        '--socket-timeout', '10',
+        '--concurrent-fragments', '16',
+        '--buffer-size', '16K',
+        '--http-chunk-size', '10M',
+        '-o', outTemplate,
+        '--no-playlist',
+        '--no-warnings',
+        'https://www.youtube.com/watch?v=' + track.id,
+    ]);
+    if (!r.ok)
+        throw new Error(r.error?.userMessage || 'yt-dlp download failed');
+    const candidates = fs
+        .readdirSync(MUSIC_DIR)
+        .filter((f) => f.startsWith(track.id + '.'))
+        .map((f) => path.join(MUSIC_DIR, f));
+    if (candidates.length === 0)
+        throw new Error('download completed but file missing');
+    return { ...track, file: candidates[0], kind: 'audio' };
+}
+export const VIDEO_QUALITIES = ['360p', '480p', '720p', '1080p', 'best'];
+export function estimateSizeMb(durationSec, quality) {
+    if (!durationSec || durationSec <= 0)
+        return 0;
+    const bitrateMbps = {
+        '360p': 0.6,
+        '480p': 1.1,
+        '720p': 2.5,
+        '1080p': 5.0,
+        best: 8.0,
+    };
+    return Math.round((bitrateMbps[quality] * durationSec) / 8);
+}
+export function parseQuality(s) {
+    if (!s)
+        return '720p';
+    const t = s.toLowerCase().trim();
+    if (t === 'best' || t === 'max')
+        return 'best';
+    if (t === '1080' || t === '1080p' || t === 'fhd')
+        return '1080p';
+    if (t === '720' || t === '720p' || t === 'hd')
+        return '720p';
+    if (t === '480' || t === '480p')
+        return '480p';
+    if (t === '360' || t === '360p')
+        return '360p';
+    return '720p';
+}
+function formatSelector(q) {
+    if (q === 'best')
+        return 'bestvideo+bestaudio/best';
+    const h = q.replace('p', '');
+    return `bestvideo[height<=${h}]+bestaudio/best[height<=${h}]`;
+}
+export async function downloadVideo(track, quality, onProgress) {
+    fs.mkdirSync(VIDEO_DIR, { recursive: true });
+    const outTemplate = path.join(VIDEO_DIR, '%(id)s.%(ext)s');
+    onProgress?.({ phase: 'downloading' });
+    const formatSel = quality === '360p'
+        ? '18/best[height<=360][ext=mp4]/best[height<=360]'
+        : quality === '480p'
+            ? '22/best[height<=480][ext=mp4]/best[height<=480]'
+            : formatSelector(quality);
+    const args = [
+        '-f', formatSel,
+        '--extractor-args', 'youtube:player_client=android,web_safari',
+        '--no-part',
+        '--no-mtime',
+        '--no-cache-dir',
+        '--socket-timeout', '15',
+        '--concurrent-fragments', '8',
+        '--buffer-size', '16K',
+        '--http-chunk-size', '5M',
+        '--retries', '5',
+        '--fragment-retries', '5',
+        '-o', outTemplate,
+        '--no-playlist',
+        '--no-warnings',
+        'https://www.youtube.com/watch?v=' + track.id,
+    ];
+    if (quality !== '360p' && quality !== '480p') {
+        args.splice(2, 0, '--merge-output-format', 'mp4');
+    }
+    const r = await runYtdlp(args);
+    if (!r.ok)
+        throw new Error(r.error?.userMessage || 'yt-dlp download failed');
+    const candidates = fs.readdirSync(VIDEO_DIR)
+        .filter((f) => f.startsWith(track.id + '.'))
+        .map((f) => path.join(VIDEO_DIR, f));
+    if (candidates.length === 0)
+        throw new Error('download completed but file missing');
+    return { ...track, file: candidates[0], kind: 'video' };
+}
+export function deleteTrackFile(track) {
+    if (!track.file)
+        return;
+    if (keepMedia())
+        return;
+    if (track.keep)
+        return;
+    try {
+        if (fs.existsSync(track.file))
+            fs.unlinkSync(track.file);
+    }
+    catch { }
+}

package/dist/core/player.js

@@ -0,0 +1,208 @@
+import { spawn } from 'child_process';
+import net from 'net';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { EventEmitter } from 'events';
+import { deleteTrackFile } from './media.js';
+const SOCK = path.join(os.tmpdir(), `blyue-mpv-${process.pid}.sock`);
+class Player extends EventEmitter {
+    proc = null;
+    sock = null;
+    queue = [];
+    state = {
+        playing: false, paused: false, current: null,
+        position: 0, duration: 0, loop: false,
+        autoplay: false,
+        lastQuery: '',
+        lastUploader: '',
+    };
+    connectAttempts = 0;
+    isRunning() { return this.proc !== null; }
+    getState() {
+        return {
+            ...this.state,
+            queue: [...this.queue],
+        };
+    }
+    setLoop(on) { this.state.loop = on; }
+    setAutoplay(on) { this.state.autoplay = on; }
+    isAutoplay() { return this.state.autoplay; }
+    setLastQuery(q, uploader) {
+        this.state.lastQuery = q;
+        this.state.lastUploader = uploader;
+    }
+    getLastQuery() { return this.state.lastQuery; }
+    getLastUploader() { return this.state.lastUploader; }
+    isLoop() { return this.state.loop; }
+    async start() {
+        if (this.proc)
+            return;
+        try {
+            if (fs.existsSync(SOCK))
+                fs.unlinkSync(SOCK);
+        }
+        catch { }
+        this.proc = spawn('mpv', ['--no-video', '--idle=yes', `--input-ipc-server=${SOCK}`,
+            '--really-quiet', '--no-terminal'], { stdio: 'ignore', detached: false });
+        this.proc.on('exit', () => {
+            this.proc = null;
+            this.state.playing = false;
+            this.state.current = null;
+            this.emit('exit');
+        });
+        const deadline = Date.now() + 3000;
+        while (Date.now() < deadline) {
+            if (fs.existsSync(SOCK))
+                break;
+            await new Promise((r) => setTimeout(r, 100));
+        }
+        await this.connect();
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            const sock = net.createConnection(SOCK);
+            sock.on('connect', () => {
+                this.sock = sock;
+                this.attachHandlers();
+                resolve();
+            });
+            sock.on('error', (err) => {
+                if (this.connectAttempts++ < 5) {
+                    setTimeout(() => this.connect().then(resolve, reject), 200);
+                }
+                else
+                    reject(err);
+            });
+        });
+    }
+    attachHandlers() {
+        if (!this.sock)
+            return;
+        let buf = '';
+        this.sock.on('data', (chunk) => {
+            buf += chunk.toString('utf8');
+            let idx;
+            while ((idx = buf.indexOf('\n')) >= 0) {
+                const line = buf.slice(0, idx).trim();
+                buf = buf.slice(idx + 1);
+                if (!line)
+                    continue;
+                try {
+                    this.handleMessage(JSON.parse(line));
+                }
+                catch { }
+            }
+        });
+    }
+    handleMessage(msg) {
+        if (msg.event === 'start-file') {
+            this.state.playing = true;
+            this.state.paused = false;
+        }
+        else if (msg.event === 'end-file') {
+            void this.onEndFile();
+        }
+        else if (msg.event === 'property-change') {
+            if (msg.name === 'pause')
+                this.state.paused = msg.data === true;
+            if (msg.name === 'time-pos')
+                this.state.position = Number(msg.data) || 0;
+            if (msg.name === 'duration')
+                this.state.duration = Number(msg.data) || 0;
+            this.emit('update', this.state);
+        }
+    }
+    async onEndFile() {
+        const finished = this.state.current;
+        if (this.state.loop && finished?.file) {
+            this.send(['loadfile', finished.file, 'replace']);
+            return;
+        }
+        if (this.queue.length > 0) {
+            if (finished)
+                deleteTrackFile(finished);
+            const next = this.queue.shift();
+            this.state.current = next;
+            this.send(['loadfile', next.file, 'replace']);
+            return;
+        }
+        if (finished)
+            deleteTrackFile(finished);
+        this.state.playing = false;
+        this.state.current = null;
+        this.state.position = 0;
+        this.state.duration = 0;
+        this.emit('queue-empty');
+    }
+    send(cmd) {
+        if (!this.sock)
+            return;
+        this.sock.write(JSON.stringify({ command: cmd }) + '\n');
+    }
+    async loadPath(file, replace) {
+        this.send(['loadfile', file, replace ? 'replace' : 'append-play']);
+        this.send(['observe_property', 1, 'time-pos']);
+        this.send(['observe_property', 2, 'duration']);
+        this.send(['observe_property', 3, 'pause']);
+    }
+    async play(track) {
+        if (!track.file)
+            throw new Error('track has no file path');
+        await this.start();
+        if (!this.state.playing && this.queue.length === 0) {
+            await this.loadPath(track.file, true);
+            this.state.current = track;
+        }
+        else {
+            await this.loadPath(track.file, false);
+            this.queue.push(track);
+        }
+    }
+    async togglePause() { this.send(['cycle', 'pause']); }
+    async next() {
+        const cur = this.state.current;
+        if (cur)
+            deleteTrackFile(cur);
+        this.send(['playlist-next']);
+    }
+    async stop() {
+        const cur = this.state.current;
+        if (cur)
+            deleteTrackFile(cur);
+        for (const t of this.queue)
+            deleteTrackFile(t);
+        this.queue = [];
+        this.send(['stop']);
+        this.state.current = null;
+        this.state.playing = false;
+    }
+    async kill() {
+        const cur = this.state.current;
+        if (cur)
+            deleteTrackFile(cur);
+        for (const t of this.queue)
+            deleteTrackFile(t);
+        this.queue = [];
+        try {
+            this.sock?.end();
+        }
+        catch { }
+        try {
+            this.sock?.destroy();
+        }
+        catch { }
+        this.sock = null;
+        try {
+            this.proc?.kill('SIGTERM');
+        }
+        catch { }
+        this.proc = null;
+        try {
+            if (fs.existsSync(SOCK))
+                fs.unlinkSync(SOCK);
+        }
+        catch { }
+    }
+}
+export const player = new Player();

package/dist/core/videoPlayer.js

@@ -0,0 +1,44 @@
+import { spawn } from 'child_process';
+import { deleteTrackFile } from './media.js';
+export function isTermux() {
+    return (!!process.env.TERMUX_VERSION ||
+        !!process.env.PREFIX?.includes('com.termux'));
+}
+export function playVideo(track) {
+    if (isTermux()) {
+        return Promise.resolve({
+            cleanup: () => deleteTrackFile(track),
+            notice: 'video playback is desktop-only — file saved at ' +
+                (track.file || '(unknown)') +
+                ' · run /cleanup to delete',
+        });
+    }
+    if (!track.file)
+        return Promise.resolve({ cleanup: () => { } });
+    return new Promise((resolve) => {
+        const file = track.file;
+        const proc = spawn('mpv', [
+            file,
+            '--force-window=yes',
+            '--keep-open=no',
+            '--really-quiet',
+            '--no-terminal',
+            '--title=BLYUE',
+        ], { stdio: 'ignore', detached: false });
+        const cleanup = () => {
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { }
+            deleteTrackFile(track);
+        };
+        proc.on('exit', () => {
+            deleteTrackFile(track);
+            resolve({ cleanup });
+        });
+        proc.on('error', () => {
+            deleteTrackFile(track);
+            resolve({ cleanup });
+        });
+    });
+}