@ciphore/radiocli 0.2.3 → 0.2.4

package/dist/player/player-controller.js

@@ -1,16 +1,17 @@
 import { spawn } from 'node:child_process';
 import { existsSync, unlinkSync } from 'node:fs';
-import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { detectPlaybackBackends, ffplayLimitedControlsMessage, playbackBackendInstallHint, vlcLimitedControlsMessage } from './backend-install.js';
-import { resolveCommand } from './command.js';
+import { airPlayMacOSOnlyMessage, detectPlaybackBackends, ffplayLimitedControlsMessage, isAirPlayPlatformSupported, playbackBackendInstallHint, vlcLimitedControlsMessage } from './backend-install.js';
+import { resolveCommand } from '../platform/executables.js';
 import { discoverAirPlayDevices } from './airplay-discovery.js';
 import { airPlaySenderHealth } from './airplay-sender-health.js';
 import { encodeWorkerStart, parseWorkerMessage, serializeWorkerMessage } from './airplay-worker-protocol.js';
 import { safeMediaTarget, sanitizeTerminalText } from '../safety.js';
 import { MpvIpcClient } from './mpv-ipc-client.js';
+import { mpvIpcPath } from '../platform/ipc.js';
 const minAirPlayTuneTimeoutSeconds = 30;
+const maxPlayerDiagnosticCharacters = 4096;
 export class PlaybackOutputError extends Error {
     constructor(message) {
         super(message);
@@ -22,6 +23,7 @@ export function isPlaybackOutputError(error) {
 }
 export class PlayerController {
     getSettings;
+    runtime;
     process = null;
     backend = null;
     ipcPath = null;
@@ -46,13 +48,17 @@ export class PlayerController {
     currentMpvMediaTitle = null;
     metadataPollInFlight = false;
     playbackStatePollInFlight = false;
+    mpvLiveRetuneInFlight = false;
     pendingMpvVolume = null;
     mpvVolumeFlush = null;
     confirmedMpvVolume = 70;
     mpvSessionId = 0;
+    playbackSessionId = 0;
     stopPromise = null;
-    constructor(getSettings) {
+    lastPlayerExit = null;
+    constructor(getSettings, runtime = { platform: process.platform, arch: process.arch, env: process.env }) {
         this.getSettings = getSettings;
+        this.runtime = runtime;
     }
     onChange(listener) {
         this.listeners.add(listener);
@@ -84,7 +90,7 @@ export class PlayerController {
         return [...(this.availableBackends ?? [])];
     }
     refreshDetectedBackends() {
-        this.availableBackends = detectPlaybackBackends();
+        this.availableBackends = detectPlaybackBackends({ platform: this.runtime.platform });
         return this.detectedBackends();
     }
     async play(station, url) {
@@ -175,7 +181,27 @@ export class PlayerController {
         });
         if (backend === 'mpv') {
             this.playWithMpv(url, station.name);
-            await this.waitForReady(backend);
+            try {
+                await this.waitForReady(backend);
+            }
+            catch (error) {
+                if (!this.shouldRetryMpvWithAlsa(error))
+                    throw error;
+                await this.stop();
+                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
+                });
+                this.playWithMpv(url, station.name, 'alsa,');
+                await this.waitForReady(backend);
+            }
         }
         else if (backend === 'ffplay') {
             this.playWithFfplay(url);
@@ -209,6 +235,9 @@ export class PlayerController {
             return unsupported;
         }
         if (this.backend === 'mpv') {
+            if (this.state.state === 'paused') {
+                return this.resumeMpvAtLiveEdge();
+            }
             try {
                 await this.sendMpv({ command: ['cycle', 'pause'] });
             }
@@ -244,6 +273,31 @@ export class PlayerController {
             return { ok: false, message: 'RadioCLI has no paused station to resume.' };
         return this.togglePause();
     }
+    async resumeMpvAtLiveEdge() {
+        if (this.mpvLiveRetuneInFlight)
+            return { ok: true, message: 'Reconnecting at the live broadcast.' };
+        const url = this.state.streamUrl ? safeMediaTarget(this.state.streamUrl) : null;
+        if (!url)
+            return { ok: false, message: 'The paused station no longer has a usable stream URL.' };
+        this.mpvLiveRetuneInFlight = true;
+        try {
+            // Reloading the same URL discards mpv's delayed live buffer and opens a
+            // fresh stream connection. This keeps radio pause/play semantics at the
+            // live edge instead of behaving like time-shifted on-demand audio.
+            await this.sendMpv({ command: ['loadfile', url, 'replace'] });
+            await this.sendMpv({ command: ['set_property', 'pause', false] });
+        }
+        catch {
+            return { ok: false, message: 'mpv could not reconnect the paused station at the live edge.' };
+        }
+        finally {
+            this.mpvLiveRetuneInFlight = false;
+        }
+        this.currentMpvMediaTitle = cleanMediaTitle(this.state.stationName ?? '') ?? 'RadioCLI';
+        this.emitMetadata({ updatedAt: new Date().toISOString() });
+        this.setState({ ...this.state, state: 'playing', ready: true, startedAt: new Date().toISOString() });
+        return { ok: true, message: 'Reconnected at the live broadcast.' };
+    }
     setVolume(volume) {
         const clamped = clampVolume(volume);
         const unsupported = this.unsupportedFfplayControl();
@@ -287,9 +341,30 @@ export class PlayerController {
         return { ok: true };
     }
     async setMuted(muted) {
-        if (this.state.muted === muted)
+        const unsupported = this.unsupportedFfplayControl();
+        if (unsupported)
+            return this.state.muted === muted ? { ok: true } : unsupported;
+        // mpv can inherit mute=yes from its configuration, so the controller's
+        // startup default is not authoritative. Explicit setters must always reach
+        // the backend even when the requested value matches our local state.
+        if (this.backend === 'mpv') {
+            try {
+                await this.sendMpv({ command: ['set_property', 'mute', muted] });
+            }
+            catch {
+                return { ok: false, message: 'mpv did not acknowledge the mute change.' };
+            }
+        }
+        else if (this.backend === 'airplay') {
+            if (!this.sendAirPlayCommand({ type: 'setMuted', muted })) {
+                return { ok: false, message: 'The AirPlay worker is not available.' };
+            }
+        }
+        else if (this.state.muted === muted) {
             return { ok: true };
-        return this.toggleMute();
+        }
+        this.setState({ ...this.state, muted });
+        return { ok: true };
     }
     stop() {
         if (this.stopPromise)
@@ -353,7 +428,7 @@ export class PlayerController {
         return { ok: true, message };
     }
     async refreshAirPlayDevices() {
-        this.availableAirPlayDevices = await discoverAirPlayDevices();
+        this.availableAirPlayDevices = await discoverAirPlayDevices({ platform: this.runtime.platform });
         return [...this.availableAirPlayDevices];
     }
     detectedAirPlayDevices() {
@@ -388,6 +463,9 @@ export class PlayerController {
     playbackUnavailableMessage() {
         const preferred = this.getSettings().preferredBackend;
         if (preferred === 'airplay') {
+            if (!isAirPlayPlatformSupported(this.runtime.platform)) {
+                return airPlayMacOSOnlyMessage;
+            }
             return `AirPlay is not ready on this install. Run radiocli doctor. ${airPlaySenderHealth().message}`;
         }
         if (preferred === 'mpv' || preferred === 'ffplay') {
@@ -395,8 +473,9 @@ export class PlayerController {
         }
         return `No playback backend found. ${playbackBackendInstallHint()}`;
     }
-    playWithMpv(url, initialTitle) {
-        this.ipcPath = createMpvIpcPath();
+    playWithMpv(url, initialTitle, recoveredAudioOutput) {
+        this.playbackSessionId += 1;
+        this.ipcPath = mpvIpcPath();
         this.mpvIpcClient = new MpvIpcClient(this.ipcPath);
         this.mpvSessionId += 1;
         this.confirmedMpvVolume = clampVolume(this.getSettings().volume);
@@ -404,9 +483,11 @@ export class PlayerController {
         this.currentMpvMediaTitle = cleanMediaTitle(initialTitle) ?? 'RadioCLI';
         this.process = spawn(resolveCommand('mpv') ?? 'mpv', [
             '--no-video',
-            '--really-quiet',
+            '--msg-level=all=warn',
             '--force-window=no',
-            ...(process.env.RADIOCLI_MPV_AUDIO_OUTPUT ? [`--ao=${process.env.RADIOCLI_MPV_AUDIO_OUTPUT}`] : []),
+            ...(recoveredAudioOutput || this.runtime.env.RADIOCLI_MPV_AUDIO_OUTPUT
+                ? [`--ao=${recoveredAudioOutput ?? this.runtime.env.RADIOCLI_MPV_AUDIO_OUTPUT}`]
+                : []),
             `--force-media-title=${this.currentMpvMediaTitle}`,
             `--volume=${this.getSettings().volume}`,
             `--input-ipc-server=${this.ipcPath}`,
@@ -417,12 +498,14 @@ export class PlayerController {
         this.wireProcess();
     }
     playWithFfplay(url) {
+        this.playbackSessionId += 1;
         this.process = spawn(resolveCommand('ffplay') ?? 'ffplay', ['-nodisp', '-hide_banner', '-loglevel', 'error', '-volume', String(this.getSettings().volume), '-autoexit', url], {
             stdio: ['pipe', 'pipe', 'pipe']
         });
         this.wireProcess();
     }
     playWithVlc(url) {
+        this.playbackSessionId += 1;
         // VLC ships a `cvlc` shim for headless playback; fall back to the main `vlc`
         // binary (resolved from app bundles when off PATH) with a dummy interface.
         const binary = resolveCommand('cvlc') ?? resolveCommand('vlc') ?? 'cvlc';
@@ -650,24 +733,49 @@ export class PlayerController {
     }
     wireProcess() {
         const child = this.process;
-        if (!child) {
+        const backend = this.backend;
+        if (!child || !backend) {
             return;
         }
+        this.lastPlayerExit = null;
+        let diagnostic = '';
+        child.stdout.on('data', chunk => {
+            diagnostic = appendPlayerDiagnostic(diagnostic, String(chunk));
+        });
+        child.stderr.on('data', chunk => {
+            diagnostic = appendPlayerDiagnostic(diagnostic, String(chunk));
+        });
         // Local players can write diagnostics indefinitely. Drain both pipes so a
         // full OS pipe buffer can never stall playback.
         child.stdout.resume?.();
         child.stderr.resume?.();
         child.on('error', error => {
+            diagnostic = appendPlayerDiagnostic(diagnostic, error.message);
+            if (this.process !== child)
+                return;
+            this.lastPlayerExit = { backend, code: null, signal: null, diagnostic, spawnError: true };
+            this.rejectPendingAirPlayReady(error);
+            this.rejectPendingAirPlayRetune(error);
+            if (backend === 'airplay') {
+                this.currentAirPlayDevice = null;
+                this.currentAirPlayDeviceId = null;
+                this.pendingAirPlayPasscode = null;
+                this.airPlaySessionEstablished = false;
+            }
+            this.process = null;
+            this.stopMpvPolling();
+            this.cleanupIpc();
             this.setState({
                 ...this.state,
-                backend: this.backend ?? 'none',
+                backend,
                 state: 'error',
                 message: error.message,
                 ready: false
             });
         });
-        child.on('exit', code => {
+        child.on('exit', (code, signal) => {
             if (this.process === child) {
+                this.lastPlayerExit = { backend, code, signal, diagnostic };
                 this.rejectPendingAirPlayRetune(new Error('AirPlay worker exited.'));
                 if (this.backend === 'airplay') {
                     this.currentAirPlayDevice = null;
@@ -789,18 +897,30 @@ export class PlayerController {
     async waitForReady(backend) {
         const timeoutMs = this.getSettings().tuneTimeoutSeconds * 1000;
         const started = Date.now();
+        const child = this.process;
+        const playbackSessionId = this.playbackSessionId;
+        const mpvClient = this.mpvIpcClient;
+        const wasSuperseded = () => this.playbackSessionId !== playbackSessionId;
+        const isCurrent = () => !wasSuperseded() && this.process === child;
         while (Date.now() - started < timeoutMs) {
-            if (!this.process) {
-                throw new Error('Player exited before the stream became ready.');
+            if (wasSuperseded()) {
+                throw new Error(`${backend} playback request was superseded.`);
+            }
+            if (!child || this.process !== child) {
+                throw this.playerExitedBeforeReady(backend);
             }
             if (backend === 'ffplay' || backend === 'vlc') {
-                await waitForStartupWindow(() => this.process, Math.min(500, timeoutMs));
+                await waitForStartupWindow(() => this.process === child ? child : null, Math.min(500, timeoutMs), () => this.playerExitedBeforeReady(backend));
+                if (wasSuperseded())
+                    throw new Error(`${backend} playback request was superseded.`);
+                if (!isCurrent())
+                    throw this.playerExitedBeforeReady(backend);
                 return;
             }
-            if (this.ipcPath) {
+            if (mpvClient) {
                 try {
-                    await this.queryMpv({ command: ['get_property', 'path'] });
-                    if (await this.hasMpvAudioStarted()) {
+                    await mpvClient.query({ command: ['get_property', 'path'] });
+                    if (await this.hasMpvAudioStarted(mpvClient) && isCurrent()) {
                         return;
                     }
                 }
@@ -810,13 +930,36 @@ export class PlayerController {
             }
             await delay(150);
         }
+        if (wasSuperseded()) {
+            throw new Error(`${backend} playback request was superseded.`);
+        }
+        if (this.process !== child)
+            throw this.playerExitedBeforeReady(backend);
         await this.stop();
         throw new Error(`Timed out while opening stream after ${this.getSettings().tuneTimeoutSeconds}s.`);
     }
-    async hasMpvAudioStarted() {
+    shouldRetryMpvWithAlsa(error) {
+        return this.runtime.platform === 'linux' &&
+            (this.runtime.arch === 'arm' || this.runtime.arch === 'arm64') &&
+            !this.runtime.env.RADIOCLI_MPV_AUDIO_OUTPUT &&
+            isAudioOutputInitializationFailure(this.lastPlayerExit?.diagnostic ?? '') &&
+            isPlaybackOutputError(error);
+    }
+    playerExitedBeforeReady(backend) {
+        const exit = this.lastPlayerExit?.backend === backend ? this.lastPlayerExit : null;
+        const reason = exit
+            ? exit.signal ? `signal ${exit.signal}` : exit.code === null ? 'without an exit code' : `code ${exit.code}`
+            : 'before its exit status was available';
+        const diagnostic = concisePlayerDiagnostic(exit?.diagnostic ?? '');
+        const message = `${backend} exited before the stream became ready (${reason})${diagnostic ? `: ${diagnostic}` : '.'}`;
+        return isBackendInitializationFailure(backend, exit, diagnostic)
+            ? new PlaybackOutputError(message)
+            : new Error(message);
+    }
+    async hasMpvAudioStarted(client) {
         const [timePos, audioPts] = await Promise.all([
-            this.queryMpv({ command: ['get_property', 'time-pos'] }).catch(() => null),
-            this.queryMpv({ command: ['get_property', 'audio-pts'] }).catch(() => null)
+            client.query({ command: ['get_property', 'time-pos'] }).catch(() => null),
+            client.query({ command: ['get_property', 'audio-pts'] }).catch(() => null)
         ]);
         return typeof timePos === 'number' || typeof audioPts === 'number';
     }
@@ -884,6 +1027,9 @@ export class PlayerController {
             if (typeof paused !== 'boolean') {
                 return false;
             }
+            if (!paused && this.state.state === 'paused' && !this.mpvLiveRetuneInFlight) {
+                return (await this.resumeMpvAtLiveEdge()).ok;
+            }
             const state = paused ? 'paused' : 'playing';
             if (this.state.state !== state) {
                 this.setState({ ...this.state, state });
@@ -928,12 +1074,6 @@ export class PlayerController {
         }
     }
 }
-export function createMpvIpcPath(platform = process.platform, pid = process.pid, timestamp = Date.now()) {
-    if (platform === 'win32') {
-        return `\\\\.\\pipe\\radiocli-${pid}-${timestamp}`;
-    }
-    return join(tmpdir(), `radiocli-${pid}-${timestamp}.sock`);
-}
 function airPlayWorkerPath() {
     const currentPath = fileURLToPath(import.meta.url);
     const extension = currentPath.endsWith('.ts') || currentPath.endsWith('.tsx') ? '.ts' : '.js';
@@ -993,15 +1133,45 @@ export function extractMpvTitle(metadata) {
     }
     return undefined;
 }
-async function waitForStartupWindow(getProcess, ms) {
+async function waitForStartupWindow(getProcess, ms, exitedError = () => new Error('Player exited before the stream became ready.')) {
     const started = Date.now();
     while (Date.now() - started < ms) {
         if (!getProcess()) {
-            throw new Error('Player exited before the stream became ready.');
+            throw exitedError();
         }
         await delay(Math.min(100, ms - (Date.now() - started)));
     }
 }
+function appendPlayerDiagnostic(current, chunk) {
+    const combined = current + chunk;
+    return combined.length <= maxPlayerDiagnosticCharacters
+        ? combined
+        : combined.slice(-maxPlayerDiagnosticCharacters);
+}
+function concisePlayerDiagnostic(value) {
+    const lines = value
+        .split(/\r?\n/)
+        .map(line => sanitizeTerminalText(line.replace(/https?:\/\/\S+/gi, '[stream URL]')))
+        .filter((line) => Boolean(line))
+        .slice(-3)
+        .join(' · ')
+        .slice(0, 700);
+    return lines;
+}
+function isAudioOutputInitializationFailure(value) {
+    return /audio output initialization failed|could not open\/initialize audio device|failed to initialize audio driver/i.test(value);
+}
+function isBackendInitializationFailure(backend, exit, diagnostic) {
+    if (isAudioOutputInitializationFailure(diagnostic))
+        return true;
+    if (exit?.spawnError)
+        return true;
+    if (/unknown (?:command line )?option|error initializing|failed to (?:create|connect to) .*(?:socket|pipe)/i.test(diagnostic))
+        return true;
+    // mpv reserves status 1 for player initialization and invalid options. A
+    // stream that could not be played uses status 2 and remains skippable.
+    return backend === 'mpv' && exit?.code === 1;
+}
 function cleanMetadataTitle(value) {
     const normalized = cleanMediaTitle(value);
     if (!normalized) {

package/dist/providers/cache.js

@@ -1,6 +1,6 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { homedir } from 'node:os';
+import { platformPaths } from '../platform/paths.js';
 import { join } from 'node:path';
 const maxCacheEntries = 256;
 const maxCacheBytes = 128 * 1024 * 1024;
@@ -103,30 +103,8 @@ export class ProviderCache {
     }
 }
 function defaultProviderCachePath() {
-    if (process.env.RADIOCLI_HOME) {
-        return join(process.env.RADIOCLI_HOME, 'radiocli-cache.json');
-    }
-    if (process.env.RADIO_ATLAS_HOME) {
-        return join(process.env.RADIO_ATLAS_HOME, 'radio-atlas-cache.json');
-    }
-    const currentPath = currentDefaultProviderCachePath();
-    const legacyPath = legacyDefaultProviderCachePath();
-    return existsSync(currentPath) || !existsSync(legacyPath) ? currentPath : legacyPath;
-}
-function currentDefaultProviderCachePath() {
-    if (process.platform === 'darwin') {
-        return join(homedir(), 'Library', 'Caches', 'radiocli', 'radiocli-cache.json');
-    }
-    if (process.platform === 'win32') {
-        return join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'RadioCLI', 'radiocli-cache.json');
-    }
-    return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'radiocli', 'radiocli-cache.json');
-}
-function legacyDefaultProviderCachePath() {
-    if (process.platform === 'darwin') {
-        return join(homedir(), 'Library', 'Application Support', 'radio-atlas', 'radio-atlas-cache.json');
-    }
-    return join(process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'radio-atlas', 'radio-atlas-cache.json');
+    const { cache, legacyCache } = platformPaths();
+    return existsSync(cache) || !existsSync(legacyCache) ? cache : legacyCache;
 }
 function writeJsonAtomically(filePath, value) {
     const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
@@ -142,7 +120,7 @@ function writeJsonAtomically(filePath, value) {
         throw error;
     }
 }
-export function backupBadFile(filePath) {
+function backupBadFile(filePath) {
     if (!existsSync(filePath)) {
         return;
     }