@ciphore/radiocli 0.2.3 → 0.2.5

package/dist/player/radio-engine.js

@@ -0,0 +1,282 @@
+import { stationKey } from '../storage/store.js';
+import { PlaybackOutputError } from './player-controller.js';
+/** Product playback rules shared by interactive and headless owners. Screen
+ * navigation and native alarm ownership deliberately remain in their adapters. */
+export class RadioEngine {
+    player;
+    providers;
+    store;
+    settings;
+    onSaved;
+    state;
+    listeners = new Set();
+    unsubscribe;
+    generation = 0;
+    tuneAbort;
+    candidate;
+    listeningKey;
+    lastTrack;
+    history = Promise.resolve();
+    checkpoint;
+    closed = false;
+    recoveryTimer;
+    recoveryAttempts = 0;
+    healthyPlaybackTimer;
+    closing;
+    constructor(player, providers, store, settings, onSaved) {
+        this.player = player;
+        this.providers = providers;
+        this.store = store;
+        this.settings = settings;
+        this.onSaved = onSaved;
+        this.state = { station: null, tuningStation: null, queue: [], playback: player.getState(), nowPlaying: null };
+        this.unsubscribe = [
+            player.onChange(playback => this.onPlayback(playback)),
+            player.onMetadata(metadata => this.onMetadata(metadata))
+        ];
+        this.checkpoint = setInterval(() => {
+            if (this.listeningKey && this.state.playback.state === 'playing' && this.state.playback.ready && !this.state.playback.buffering) {
+                const at = new Date();
+                this.persist(() => store.checkpointActiveListeningSession(at));
+            }
+        }, 30_000);
+        this.checkpoint.unref();
+    }
+    snapshot() { return { ...this.state, playback: { ...this.state.playback }, queue: [...this.state.queue] }; }
+    onChange(listener) {
+        this.listeners.add(listener);
+        listener(this.snapshot());
+        return () => this.listeners.delete(listener);
+    }
+    clearWarning() { if (this.state.warning) {
+        this.state.warning = undefined;
+        this.emit();
+    } }
+    cancel() {
+        this.generation++;
+        clearTimeout(this.recoveryTimer);
+        this.recoveryTimer = undefined;
+        clearTimeout(this.healthyPlaybackTimer);
+        this.healthyPlaybackTimer = undefined;
+        this.tuneAbort?.abort(new DOMException('Tuning canceled.', 'AbortError'));
+        this.tuneAbort = undefined;
+        if (this.candidate && this.state.playback.ready)
+            this.candidate.generation = this.generation;
+        this.state.tuningStation = null;
+        this.state.message = undefined;
+        this.emit();
+    }
+    async tune(station, options = {}) {
+        if (this.closed)
+            throw new Error('RadioCLI playback engine is closed.');
+        options.signal?.throwIfAborted();
+        this.cancel();
+        this.recoveryAttempts = options.recoveryAttempt ?? 0;
+        const generation = this.generation;
+        const controller = new AbortController();
+        const deadline = setTimeout(() => controller.abort(new DOMException('Tuning exceeded 90 seconds.', 'TimeoutError')), 90_000);
+        deadline.unref();
+        this.tuneAbort = controller;
+        const abort = () => controller.abort(options.signal?.reason);
+        options.signal?.addEventListener('abort', abort, { once: true });
+        const queue = options.queue?.length ? options.queue : [station];
+        let next = station;
+        try {
+            while (true) {
+                controller.signal.throwIfAborted();
+                this.state.tuningStation = next;
+                this.state.nowPlaying = null;
+                this.emit();
+                try {
+                    // A ready receiver can keep its connection while resolving a new URL.
+                    // Pending startup and local processes are canceled before replacement.
+                    const playback = this.player.getState();
+                    if (!(playback.backend === 'airplay' && playback.ready && playback.state === 'playing'))
+                        await this.player.stop();
+                    controller.signal.throwIfAborted();
+                    const resolved = await this.providers.resolve(next, { signal: controller.signal });
+                    controller.signal.throwIfAborted();
+                    if (generation !== this.generation)
+                        throw new DOMException('Tuning canceled.', 'AbortError');
+                    this.candidate = { station: next, url: resolved.url, generation };
+                    this.lastTrack = undefined;
+                    await this.player.play(next, resolved.url, { startPaused: options.startPaused, signal: controller.signal });
+                    controller.signal.throwIfAborted();
+                    this.onPlayback(this.player.getState());
+                    this.state.station = next;
+                    this.state.queue = [...queue];
+                    this.state.tuningStation = null;
+                    this.state.message = undefined;
+                    const tuned = next;
+                    this.persist(() => this.store.addRecent(tuned));
+                    this.emit();
+                    await this.flushHistory();
+                    controller.signal.throwIfAborted();
+                    if (generation !== this.generation)
+                        throw new DOMException('Tuning canceled.', 'AbortError');
+                    return next;
+                }
+                catch (error) {
+                    if (controller.signal.aborted || generation !== this.generation)
+                        throw controller.signal.reason ?? error;
+                    const index = queue.findIndex(item => stationKey(item) === stationKey(next));
+                    const following = index >= 0 ? queue[index + 1] : undefined;
+                    if (!following || options.startPaused || options.skipBroken === false || !this.settings().skipBrokenStreams || error instanceof PlaybackOutputError)
+                        throw error;
+                    this.state.message = `${error instanceof Error ? error.message : 'Could not tune station.'} Skipping to ${following.name}.`;
+                    this.state.tuningStation = following;
+                    this.emit();
+                    await abortableDelay(1000, controller.signal);
+                    next = following;
+                }
+            }
+        }
+        finally {
+            clearTimeout(deadline);
+            options.signal?.removeEventListener('abort', abort);
+            if (generation === this.generation) {
+                this.tuneAbort = undefined;
+                this.state.tuningStation = null;
+                this.emit();
+            }
+        }
+    }
+    async stop(options = {}) {
+        this.cancel();
+        this.candidate = undefined;
+        this.finishListening();
+        this.state.nowPlaying = null;
+        if (!options.retainSelection) {
+            this.state.station = null;
+            this.state.queue = [];
+        }
+        await this.player.stop();
+        this.onPlayback(this.player.getState());
+        this.emit();
+        await this.flushHistory();
+    }
+    async pause() { const result = await this.player.pause(); this.onPlayback(this.player.getState()); await this.flushHistory(); return result; }
+    async resume() { const result = await this.player.resume(); this.onPlayback(this.player.getState()); await this.flushHistory(); return result; }
+    select(station, queue = this.state.queue) { this.state.station = station; this.state.queue = [...queue]; this.emit(); }
+    async flushHistory() { await this.history; }
+    close() {
+        return this.closing ??= (async () => {
+            this.closed = true;
+            clearInterval(this.checkpoint);
+            try {
+                await this.stop();
+            }
+            finally {
+                for (const unsubscribe of this.unsubscribe)
+                    unsubscribe();
+                this.listeners.clear();
+            }
+        })();
+    }
+    onPlayback(playback) {
+        this.state.playback = playback;
+        const active = this.candidate;
+        const belongs = active && active.generation === this.generation && (!playback.streamUrl || playback.streamUrl === active.url);
+        if (belongs && playback.ready && playback.state === 'playing' && !playback.buffering) {
+            if (this.recoveryAttempts > 0 && !this.healthyPlaybackTimer) {
+                const generation = this.generation;
+                this.healthyPlaybackTimer = setTimeout(() => {
+                    this.healthyPlaybackTimer = undefined;
+                    if (generation === this.generation && !this.closed)
+                        this.recoveryAttempts = 0;
+                }, 60_000);
+                this.healthyPlaybackTimer.unref();
+            }
+            const key = stationKey(active.station);
+            if (this.listeningKey !== key) {
+                this.finishListening();
+                this.listeningKey = key;
+                const at = new Date();
+                this.persist(() => this.store.startListeningSession(active.station, at));
+            }
+        }
+        else {
+            clearTimeout(this.healthyPlaybackTimer);
+            this.healthyPlaybackTimer = undefined;
+            if (!playback.ready || playback.state !== 'playing' || playback.buffering)
+                this.finishListening();
+        }
+        if (belongs && playback.state === 'error' && !this.state.tuningStation && !this.closed && this.player.recoverableFailure())
+            this.scheduleRecovery(active.station);
+        this.emit();
+    }
+    onMetadata(metadata) {
+        const active = this.candidate;
+        if (!active || active.generation !== this.generation || this.state.playback.streamUrl && this.state.playback.streamUrl !== active.url)
+            return;
+        this.state.nowPlaying = metadata;
+        const key = `${stationKey(active.station)}:${metadata.title}`;
+        if (metadata.title && key !== this.lastTrack) {
+            this.lastTrack = key;
+            this.persist(() => this.store.recordTrack(active.station, metadata.title));
+        }
+        this.emit();
+    }
+    finishListening() {
+        if (!this.listeningKey)
+            return;
+        this.listeningKey = undefined;
+        const at = new Date();
+        this.persist(() => this.store.finishActiveListeningSession(at));
+    }
+    scheduleRecovery(station) {
+        if (this.recoveryTimer)
+            return;
+        if (this.recoveryAttempts >= 3) {
+            this.state.message = 'Reconnection stopped after 3 attempts. Select the station to try again.';
+            return;
+        }
+        const attempt = ++this.recoveryAttempts;
+        const generation = this.generation;
+        this.state.message = `Stream connection interrupted. Reconnecting ${station.name} (${attempt}/3).`;
+        this.recoveryTimer = setTimeout(() => {
+            this.recoveryTimer = undefined;
+            if (this.closed || generation !== this.generation)
+                return;
+            void this.tune(station, { queue: this.state.queue, recoveryAttempt: attempt, skipBroken: false }).catch(error => {
+                if (this.closed || error.name === 'AbortError')
+                    return;
+                if (this.player.recoverableFailure() && this.recoveryAttempts < 3)
+                    this.scheduleRecovery(station);
+                else {
+                    this.state.message = `Could not reconnect ${station.name}: ${error instanceof Error ? error.message : String(error)}`;
+                    this.emit();
+                }
+            });
+        }, 1000 * 2 ** (attempt - 1));
+        this.recoveryTimer.unref();
+    }
+    persist(write) {
+        this.history = this.history.then(async () => {
+            try {
+                const saved = await write();
+                this.onSaved?.(saved);
+            }
+            catch (error) {
+                const code = error.code;
+                this.state.warning = `Listening history was not saved${code ? ` (${code})` : ''}. Check storage permissions or set RADIOCLI_HOME to a private writable directory.`;
+                this.emit();
+            }
+        });
+    }
+    emit() { for (const listener of this.listeners) {
+        try {
+            listener(this.snapshot());
+        }
+        catch { /* Isolate adapters. */ }
+    } }
+}
+function abortableDelay(ms, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const finish = () => { signal.removeEventListener('abort', abort); resolve(); };
+        const timer = setTimeout(finish, ms);
+        const abort = () => { clearTimeout(timer); signal.removeEventListener('abort', abort); reject(signal.reason); };
+        signal.addEventListener('abort', abort, { once: true });
+    });
+}

package/dist/playlists/playlist.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
+import { customStationId } from '../storage/station-identity.js';
 export function parsePlaylistFile(filePath, depth = 0) {
     if (!existsSync(filePath)) {
         throw new Error(`Playlist not found: ${filePath}`);
@@ -34,7 +35,7 @@ export function writeM3u(filePath, stations) {
 export function stationFromUrl(url, name = url) {
     const cleanedName = cleanName(name) || url;
     return {
-        id: stableId(url),
+        id: customStationId(url),
         provider: 'playlist',
         name: cleanedName,
         tags: ['custom'],
@@ -110,27 +111,28 @@ 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)}`;
+    // Decode in one pass: CDATA is literal text, and &amp;lt; represents &lt;,
+    // not a second reference to expand. No DTD or external entity is evaluated.
+    const entities = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+    return value?.replace(/<!\[CDATA\[([\s\S]*?)\]\]>|&(amp|lt|gt|quot|apos|#\d+|#x[\da-fA-F]+);/g, (reference, cdata, entity) => {
+        if (cdata !== undefined)
+            return cdata;
+        if (!entity)
+            return reference;
+        if (!entity.startsWith('#'))
+            return entities[entity] ?? reference;
+        const point = entity.startsWith('#x') ? Number.parseInt(entity.slice(2), 16) : Number(entity.slice(1));
+        return Number.isInteger(point) && point > 0 && point <= 0x10ffff && !(point >= 0xd800 && point <= 0xdfff)
+            ? String.fromCodePoint(point) : reference;
+    }).trim();
 }
 function normalizePlaylistTarget(target, root) {
     const trimmed = target.trim();
     if (isSupportedTarget(trimmed)) {
         return trimmed;
     }
-    if (!/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) {
+    // On Windows a native drive path has a colon but is not a URL scheme.
+    if (isAbsolute(trimmed) || !/^[a-z][a-z0-9+.-]*:/i.test(trimmed)) {
         const filePath = isAbsolute(trimmed) ? trimmed : resolve(root, trimmed);
         if (existsSync(filePath)) {
             return filePath;