@ciphore/radiocli 0.1.0

package/dist/player/player-controller.js

@@ -0,0 +1,494 @@
+import { spawn } from 'node:child_process';
+import { existsSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Socket } from 'node:net';
+import { detectPlaybackBackends, playbackBackendInstallHint } from './backend-install.js';
+export class PlayerController {
+    getSettings;
+    process = null;
+    backend = null;
+    ipcPath = null;
+    metadataTimer = null;
+    playbackStateTimer = null;
+    state = { backend: 'none', state: 'idle', volume: 70, muted: false, ready: false };
+    listeners = new Set();
+    metadataListeners = new Set();
+    availableBackends = null;
+    nextMpvRequestId = 1;
+    currentMpvMediaTitle = null;
+    constructor(getSettings) {
+        this.getSettings = getSettings;
+    }
+    onChange(listener) {
+        this.listeners.add(listener);
+        listener(this.state);
+        return () => this.listeners.delete(listener);
+    }
+    onMetadata(listener) {
+        this.metadataListeners.add(listener);
+        return () => this.metadataListeners.delete(listener);
+    }
+    getState() {
+        return { ...this.state };
+    }
+    diagnostics() {
+        return {
+            backend: this.state.backend,
+            availableBackends: this.detectedBackends(),
+            preferredBackend: this.getSettings().preferredBackend,
+            active: Boolean(this.process),
+            streamUrl: this.state.streamUrl,
+            stationName: this.state.stationName,
+            volume: this.state.volume,
+            muted: this.state.muted,
+            startedAt: this.state.startedAt,
+            ready: this.state.ready
+        };
+    }
+    detectedBackends() {
+        return [...(this.availableBackends ?? [])];
+    }
+    refreshDetectedBackends() {
+        this.availableBackends = detectPlaybackBackends();
+        return this.detectedBackends();
+    }
+    async play(station, url) {
+        await this.stop();
+        const backend = this.selectBackend();
+        if (!backend) {
+            throw new Error(`No playback backend found. ${playbackBackendInstallHint()}`);
+        }
+        this.backend = backend;
+        this.setState({
+            backend,
+            state: 'loading',
+            message: `Opening ${station.name}`,
+            volume: this.getSettings().volume,
+            muted: false,
+            stationName: station.name,
+            streamUrl: url,
+            ready: false
+        });
+        backend === 'mpv' ? this.playWithMpv(url, station.name) : this.playWithFfplay(url);
+        await this.waitForReady(backend);
+        this.setState({
+            backend,
+            state: 'playing',
+            message: station.name,
+            volume: this.getSettings().volume,
+            muted: false,
+            stationName: station.name,
+            streamUrl: url,
+            startedAt: new Date().toISOString(),
+            ready: true
+        });
+        if (backend === 'mpv') {
+            this.startMpvMetadataPolling();
+        }
+    }
+    async togglePause() {
+        if (!this.process || !this.backend || !this.state.ready) {
+            return;
+        }
+        if (this.backend === 'mpv') {
+            await this.sendMpv({ command: ['cycle', 'pause'] }).catch(() => undefined);
+            const synced = await this.syncMpvPlaybackState();
+            if (synced) {
+                return;
+            }
+        }
+        else {
+            this.process.stdin.write('p');
+        }
+        this.setState({
+            ...this.state,
+            state: this.state.state === 'paused' ? 'playing' : 'paused'
+        });
+    }
+    async setVolume(volume) {
+        const clamped = clampVolume(volume);
+        if (this.backend === 'mpv') {
+            await this.sendMpv({ command: ['set_property', 'volume', clamped] }).catch(() => undefined);
+        }
+        else if (this.backend === 'ffplay' && this.process) {
+            const delta = clamped - this.state.volume;
+            const key = delta > 0 ? '0' : '9';
+            const steps = Math.min(10, Math.ceil(Math.abs(delta) / 5));
+            for (let index = 0; index < steps; index += 1) {
+                this.process.stdin.write(key);
+            }
+        }
+        this.setState({ ...this.state, volume: clamped });
+    }
+    async adjustVolume(delta) {
+        await this.setVolume(this.state.volume + delta);
+    }
+    async toggleMute() {
+        const muted = !this.state.muted;
+        if (this.backend === 'mpv') {
+            await this.sendMpv({ command: ['set_property', 'mute', muted] }).catch(() => undefined);
+        }
+        else if (this.backend === 'ffplay' && this.process) {
+            this.process.stdin.write('m');
+        }
+        this.setState({ ...this.state, muted });
+    }
+    async stop() {
+        this.stopMpvPolling();
+        if (this.backend === 'mpv') {
+            await this.sendMpv({ command: ['quit'] }).catch(() => undefined);
+        }
+        if (this.process && !this.process.killed) {
+            this.process.kill('SIGTERM');
+        }
+        this.process = null;
+        this.cleanupIpc();
+        this.setState({
+            ...this.state,
+            backend: this.backend ?? 'none',
+            state: 'stopped',
+            ready: false
+        });
+    }
+    selectBackend() {
+        const preferred = this.getSettings().preferredBackend;
+        const backends = this.availableBackends ?? this.refreshDetectedBackends();
+        if (preferred === 'mpv') {
+            return backends.includes('mpv') ? 'mpv' : null;
+        }
+        if (preferred === 'ffplay') {
+            return backends.includes('ffplay') ? 'ffplay' : null;
+        }
+        if (backends.includes('mpv')) {
+            return 'mpv';
+        }
+        if (backends.includes('ffplay')) {
+            return 'ffplay';
+        }
+        return null;
+    }
+    playWithMpv(url, initialTitle) {
+        this.ipcPath = join(tmpdir(), `radiocli-${process.pid}-${Date.now()}.sock`);
+        this.currentMpvMediaTitle = cleanMediaTitle(initialTitle) ?? 'RadioCLI';
+        this.process = spawn('mpv', [
+            '--no-video',
+            '--really-quiet',
+            '--force-window=no',
+            `--force-media-title=${this.currentMpvMediaTitle}`,
+            `--volume=${this.getSettings().volume}`,
+            `--input-ipc-server=${this.ipcPath}`,
+            url
+        ], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.wireProcess();
+    }
+    playWithFfplay(url) {
+        this.process = spawn('ffplay', ['-nodisp', '-hide_banner', '-loglevel', 'error', '-volume', String(this.getSettings().volume), '-autoexit', url], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.wireProcess();
+    }
+    wireProcess() {
+        const child = this.process;
+        if (!child) {
+            return;
+        }
+        child.on('error', error => {
+            this.setState({
+                ...this.state,
+                backend: this.backend ?? 'none',
+                state: 'error',
+                message: error.message,
+                ready: false
+            });
+        });
+        child.on('exit', code => {
+            if (this.process === child) {
+                this.process = null;
+                this.stopMpvPolling();
+                this.cleanupIpc();
+                this.setState({
+                    ...this.state,
+                    backend: this.backend ?? 'none',
+                    state: code === 0 || code === null ? 'stopped' : 'error',
+                    message: code === 0 || code === null ? undefined : `player exited with code ${code}`,
+                    ready: false
+                });
+            }
+        });
+    }
+    sendMpv(payload) {
+        return this.queryMpv(payload).then(() => undefined);
+    }
+    queryMpv(payload) {
+        if (!this.ipcPath) {
+            return Promise.resolve(null);
+        }
+        return new Promise((resolve, reject) => {
+            const socket = new Socket();
+            let buffer = '';
+            let settled = false;
+            const requestId = this.nextMpvRequestId;
+            this.nextMpvRequestId = this.nextMpvRequestId >= Number.MAX_SAFE_INTEGER ? 1 : this.nextMpvRequestId + 1;
+            const requestPayload = attachMpvRequestId(payload, requestId);
+            const settle = (callback) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                socket.end();
+                callback();
+            };
+            const timeout = setTimeout(() => {
+                socket.destroy();
+                settle(() => reject(new Error('mpv IPC timed out.')));
+            }, 1000);
+            socket.once('error', error => {
+                settle(() => reject(error));
+            });
+            socket.on('data', chunk => {
+                buffer += chunk.toString('utf8');
+                let newlineIndex = buffer.indexOf('\n');
+                while (newlineIndex !== -1) {
+                    const line = buffer.slice(0, newlineIndex);
+                    buffer = buffer.slice(newlineIndex + 1);
+                    newlineIndex = buffer.indexOf('\n');
+                    if (!line.trim()) {
+                        continue;
+                    }
+                    try {
+                        const parsed = JSON.parse(line);
+                        if (parsed.request_id !== requestId) {
+                            continue;
+                        }
+                        if (parsed.error && parsed.error !== 'success') {
+                            settle(() => reject(new Error(`mpv IPC failed: ${parsed.error}`)));
+                        }
+                        else {
+                            settle(() => resolve(parsed.data ?? null));
+                        }
+                    }
+                    catch {
+                        settle(() => resolve(null));
+                    }
+                }
+            });
+            socket.connect(this.ipcPath, () => {
+                socket.write(`${JSON.stringify(requestPayload)}\n`, error => {
+                    if (error) {
+                        settle(() => reject(error));
+                    }
+                });
+            });
+        });
+    }
+    async waitForReady(backend) {
+        const timeoutMs = this.getSettings().tuneTimeoutSeconds * 1000;
+        const started = Date.now();
+        while (Date.now() - started < timeoutMs) {
+            if (!this.process) {
+                throw new Error('Player exited before the stream became ready.');
+            }
+            if (backend === 'ffplay') {
+                await waitForStartupWindow(() => this.process, Math.min(500, timeoutMs));
+                return;
+            }
+            if (this.ipcPath && existsSync(this.ipcPath)) {
+                try {
+                    await this.queryMpv({ command: ['get_property', 'path'] });
+                    return;
+                }
+                catch {
+                    // The IPC socket can exist briefly before accepting commands.
+                }
+            }
+            await delay(150);
+        }
+        await this.stop();
+        throw new Error(`Timed out while opening stream after ${this.getSettings().tuneTimeoutSeconds}s.`);
+    }
+    startMpvMetadataPolling() {
+        this.stopMpvPolling();
+        this.metadataTimer = setInterval(() => {
+            void this.pollMpvMetadata();
+        }, 2500);
+        this.playbackStateTimer = setInterval(() => {
+            void this.syncMpvPlaybackState();
+        }, 500);
+        void this.pollMpvMetadata();
+        void this.syncMpvPlaybackState();
+    }
+    stopMpvPolling() {
+        if (this.metadataTimer) {
+            clearInterval(this.metadataTimer);
+            this.metadataTimer = null;
+        }
+        if (this.playbackStateTimer) {
+            clearInterval(this.playbackStateTimer);
+            this.playbackStateTimer = null;
+        }
+    }
+    async pollMpvMetadata() {
+        if (this.backend !== 'mpv' || !this.process) {
+            return;
+        }
+        const metadata = await this.queryMpv({ command: ['get_property', 'metadata'] }).catch(() => null);
+        const elapsed = await this.queryMpv({ command: ['get_property', 'time-pos'] }).catch(() => null);
+        if (typeof elapsed === 'number') {
+            this.setState({ ...this.state, elapsedSeconds: Math.floor(elapsed) });
+        }
+        const title = extractMpvTitle(metadata);
+        if (title) {
+            await this.setMpvMediaTitle(title);
+            this.emitMetadata({ title, raw: JSON.stringify(metadata), updatedAt: new Date().toISOString() });
+        }
+    }
+    async setMpvMediaTitle(title) {
+        const cleaned = cleanMediaTitle(title);
+        if (!cleaned || cleaned === this.currentMpvMediaTitle) {
+            return;
+        }
+        this.currentMpvMediaTitle = cleaned;
+        await this.sendMpv({ command: ['set_property', 'force-media-title', cleaned] }).catch(() => undefined);
+    }
+    async syncMpvPlaybackState() {
+        if (this.backend !== 'mpv' || !this.process || !this.state.ready) {
+            return false;
+        }
+        const paused = await this.queryMpv({ command: ['get_property', 'pause'] }).catch(() => null);
+        if (typeof paused !== 'boolean') {
+            return false;
+        }
+        const state = paused ? 'paused' : 'playing';
+        if (this.state.state !== state) {
+            this.setState({ ...this.state, state });
+        }
+        return true;
+    }
+    emitMetadata(metadata) {
+        for (const listener of this.metadataListeners) {
+            listener(metadata);
+        }
+    }
+    cleanupIpc() {
+        if (this.ipcPath && existsSync(this.ipcPath)) {
+            try {
+                unlinkSync(this.ipcPath);
+            }
+            catch {
+                // mpv may clean up the socket first.
+            }
+        }
+        this.ipcPath = null;
+        this.currentMpvMediaTitle = null;
+    }
+    setState(state) {
+        this.state = state;
+        for (const listener of this.listeners) {
+            listener(state);
+        }
+    }
+}
+function clampVolume(volume) {
+    return Math.min(100, Math.max(0, Math.round(volume)));
+}
+function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function extractMpvTitle(metadata) {
+    if (!metadata) {
+        return undefined;
+    }
+    const candidates = [
+        metadata['icy-title'],
+        metadata.StreamTitle,
+        metadata.title,
+        metadata.Title,
+        metadata['icy-name'],
+        metadata.Name
+    ];
+    for (const candidate of candidates) {
+        const title = cleanMetadataTitle(candidate);
+        if (title) {
+            return title;
+        }
+    }
+    return undefined;
+}
+function attachMpvRequestId(payload, requestId) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        return { ...payload, request_id: requestId };
+    }
+    return { command: payload, request_id: requestId };
+}
+async function waitForStartupWindow(getProcess, ms) {
+    const started = Date.now();
+    while (Date.now() - started < ms) {
+        if (!getProcess()) {
+            throw new Error('Player exited before the stream became ready.');
+        }
+        await delay(Math.min(100, ms - (Date.now() - started)));
+    }
+}
+function cleanMetadataTitle(value) {
+    const normalized = cleanMediaTitle(value);
+    if (!normalized) {
+        return undefined;
+    }
+    const fields = parseMetadataFields(normalized);
+    if (fields.size > 0) {
+        const title = firstField(fields, ['title', 'streamtitle', 'text', 'song', 'track', 'name']);
+        const artist = firstField(fields, ['artist', 'artists', 'performer', 'albumartist']) ?? leadingMetadataPrefix(normalized);
+        const album = firstField(fields, ['album']);
+        if (artist && title) {
+            return `${artist} - ${title}`;
+        }
+        return title ?? artist ?? album;
+    }
+    return stripIcyStreamTitleWrapper(normalized);
+}
+function parseMetadataFields(value) {
+    const fields = new Map();
+    const normalized = value.replace(/=\s*""([^",;][^,;]*?)"/g, '="$1"');
+    const pattern = /(?:^|[\s,;])([A-Za-z][A-Za-z0-9_-]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^;,]*?)(?=\s+[A-Za-z][A-Za-z0-9_-]*\s*=|[;,]|$))/g;
+    for (const match of normalized.matchAll(pattern)) {
+        const key = normalizeMetadataKey(match[1] ?? '');
+        const rawValue = match[2] ?? match[3] ?? match[4] ?? '';
+        const cleanedValue = cleanMediaTitle(rawValue.replace(/\\"/g, '"').replace(/\\'/g, "'"));
+        if (key && cleanedValue && !fields.has(key)) {
+            fields.set(key, cleanedValue);
+        }
+    }
+    return fields;
+}
+function firstField(fields, keys) {
+    for (const key of keys) {
+        const value = fields.get(key);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function normalizeMetadataKey(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]/g, '');
+}
+function leadingMetadataPrefix(value) {
+    const firstFieldIndex = value.search(/[A-Za-z][A-Za-z0-9_-]*\s*=/);
+    if (firstFieldIndex <= 0) {
+        return undefined;
+    }
+    return cleanMediaTitle(value.slice(0, firstFieldIndex).replace(/[-–—:;,]\s*$/, ''));
+}
+function cleanMediaTitle(value) {
+    const cleaned = value?.replace(/\s+/g, ' ').trim().replace(/^"+|"+$/g, '').trim();
+    return cleaned || undefined;
+}
+function stripIcyStreamTitleWrapper(value) {
+    const wrapped = value.match(/^StreamTitle=['"]?([^'";]+)['"]?;?$/i);
+    const title = wrapped?.[1] ?? value;
+    return title.replace(/\s+/g, ' ').trim() || undefined;
+}

package/dist/playlists/playlist.js

@@ -0,0 +1,169 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+export function parsePlaylistFile(filePath, depth = 0) {
+    if (!existsSync(filePath)) {
+        throw new Error(`Playlist not found: ${filePath}`);
+    }
+    const text = readFileSync(filePath, 'utf8');
+    const root = dirname(filePath);
+    const lower = filePath.toLowerCase();
+    let stations;
+    if (lower.endsWith('.pls')) {
+        stations = parsePls(text, root, depth);
+    }
+    else if (lower.endsWith('.xspf')) {
+        stations = parseXspf(text);
+    }
+    else {
+        stations = parseM3u(text, basename(filePath), root, depth);
+    }
+    return dedupeStations(stations);
+}
+export function writeM3u(filePath, stations) {
+    const lines = ['#EXTM3U'];
+    for (const station of stations) {
+        const url = station.streamUrl;
+        if (!url) {
+            continue;
+        }
+        lines.push(`#EXTINF:-1,${station.name}`);
+        lines.push(url);
+    }
+    writeFileSync(filePath, `${lines.join('\n')}\n`, 'utf8');
+}
+export function stationFromUrl(url, name = url) {
+    const cleanedName = cleanName(name) || url;
+    return {
+        id: stableId(url),
+        provider: 'playlist',
+        name: cleanedName,
+        tags: ['custom'],
+        streamUrl: url
+    };
+}
+function parseM3u(text, fallbackName, root, depth) {
+    const stations = [];
+    let pendingName;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) {
+            continue;
+        }
+        if (line.startsWith('#EXTINF')) {
+            pendingName = line.split(',').slice(1).join(',').trim() || undefined;
+            continue;
+        }
+        if (line.startsWith('#')) {
+            continue;
+        }
+        const nestedPath = nestedPlaylistPath(line, root);
+        if (nestedPath && depth < 2) {
+            stations.push(...parsePlaylistFile(nestedPath, depth + 1));
+            pendingName = undefined;
+            continue;
+        }
+        const url = normalizePlaylistTarget(line, root);
+        if (url) {
+            stations.push(stationFromUrl(url, pendingName ?? fallbackName));
+            pendingName = undefined;
+        }
+    }
+    return stations;
+}
+function parsePls(text, root, depth) {
+    const files = new Map();
+    const titles = new Map();
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        const match = /^(File|Title)(\d+)=(.*)$/i.exec(line);
+        if (!match) {
+            continue;
+        }
+        const index = Number(match[2]);
+        if (match[1]?.toLowerCase() === 'file') {
+            files.set(index, match[3] ?? '');
+        }
+        else {
+            titles.set(index, match[3] ?? '');
+        }
+    }
+    return [...files.entries()].flatMap(([index, target]) => {
+        const nestedPath = nestedPlaylistPath(target, root);
+        if (nestedPath && depth < 2) {
+            return parsePlaylistFile(nestedPath, depth + 1);
+        }
+        const url = normalizePlaylistTarget(target, root);
+        return url ? [stationFromUrl(url, titles.get(index) || url)] : [];
+    });
+}
+function parseXspf(text) {
+    const tracks = [...text.matchAll(/<track\b[\s\S]*?<\/track>/gi)].map(match => match[0]);
+    return tracks.flatMap(track => {
+        const location = decodeXml(firstTag(track, 'location'));
+        if (!location || !isSupportedTarget(location)) {
+            return [];
+        }
+        return [stationFromUrl(location, decodeXml(firstTag(track, 'title')) || location)];
+    });
+}
+function firstTag(text, tag) {
+    return new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i').exec(text)?.[1]?.trim();
+}
+function decodeXml(value) {
+    return value
+        ?.replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
+function stableId(value) {
+    let hash = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        hash = (hash * 31 + value.charCodeAt(index)) >>> 0;
+    }
+    return `custom-${hash.toString(16)}`;
+}
+function normalizePlaylistTarget(target, root) {
+    const trimmed = target.trim();
+    if (isSupportedTarget(trimmed)) {
+        return trimmed;
+    }
+    if (!/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) {
+        const filePath = isAbsolute(trimmed) ? trimmed : resolve(root, trimmed);
+        if (existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+function nestedPlaylistPath(target, root) {
+    const trimmed = target.trim();
+    if (!/\.(m3u8?|pls|xspf)$/i.test(trimmed)) {
+        return null;
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+        return null;
+    }
+    const filePath = isAbsolute(trimmed) ? trimmed : join(root, trimmed);
+    return existsSync(filePath) ? filePath : null;
+}
+function isSupportedTarget(target) {
+    return /^(https?|file):\/\//i.test(target);
+}
+function cleanName(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function dedupeStations(stations) {
+    const seen = new Set();
+    const deduped = [];
+    for (const station of stations) {
+        if (!station.streamUrl || seen.has(station.streamUrl)) {
+            continue;
+        }
+        seen.add(station.streamUrl);
+        deduped.push(station);
+    }
+    return deduped;
+}