@ciphore/radiocli 0.2.3 → 0.2.5

package/dist/player/backend-install.js

@@ -1,14 +1,22 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { commandExists } from './command.js';
+import { ffplayInstallCommand, mpvInstallCommand } from '../platform/packages.js';
+import { readLinuxOsRelease } from '../platform/runtime.js';
+import { commandExists } from '../platform/executables.js';
+import { airPlayPolicy } from './airplay-policy.js';
+export { isAirPlayPlatformSupported } from './airplay-policy.js';
 import { airPlaySenderHealth } from './airplay-sender-health.js';
 export const ffplayLimitedControlsMessage = 'ffplay fallback has limited controls. Install mpv for pause, mute, volume, and media keys.';
 export const vlcLimitedControlsMessage = 'VLC fallback has limited controls. Install mpv for pause, mute, volume, and media keys.';
-export function detectPlaybackBackends({ platform = process.platform, hasCommand = commandExists, hasAirPlaySender = hasAirPlaySenderPackage } = {}) {
+export function airPlayLocalDeviceLabel(platform = process.platform) {
+    return platform === 'darwin' ? 'this Mac' : 'this device';
+}
+export function detectPlaybackBackends({ platform = process.platform, settings, env, release, hasCommand = commandExists, hasAirPlaySender = hasAirPlaySenderPackage } = {}) {
     const backends = ['mpv', 'ffplay'].filter(hasCommand);
     if (hasCommand('cvlc') || hasCommand('vlc')) {
         backends.push('vlc');
     }
-    if (platform === 'darwin' && hasCommand('ffmpeg') && hasCommand('dns-sd') && hasAirPlaySender()) {
+    // This is only a cheap candidate check. Discovery and explicit diagnostics
+    // separately verify the daemon and isolated native sender loadability.
+    if (airPlayPolicy(settings, { platform, env, release }).enabled && hasCommand('ffmpeg') && hasCommand(platform === 'linux' ? 'avahi-browse' : 'dns-sd') && hasAirPlaySender()) {
         backends.push('airplay');
     }
     return backends;
@@ -69,16 +77,16 @@ export function playbackBackendCapabilities(backend) {
 export function playbackBackendLabel(backend) {
     return playbackBackendCapabilities(backend).label;
 }
-export function playbackBackendInstallHint(platform = process.platform, osRelease = readLinuxOsRelease()) {
-    return `Run radiocli setup to install mpv for playback (${mpvInstallCommand(platform, osRelease)}), then run radiocli doctor.`;
+export function playbackBackendInstallHint(platform = process.platform, osRelease = readLinuxOsRelease(platform), options = {}) {
+    return `Run radiocli setup to install mpv for playback (${mpvInstallCommand(platform, osRelease, process.env, options)}), then run radiocli doctor.`;
 }
-export function playbackBackendStatusLines(backends, platform = process.platform, osRelease = readLinuxOsRelease()) {
+export function playbackBackendStatusLines(backends, platform = process.platform, osRelease = readLinuxOsRelease(platform), options = {}) {
     const backendSet = new Set(backends);
     const lines = [
         'npm_install=RadioCLI installs the optional AirPlay sender when native dependencies are available; playback tools come from mpv and FFmpeg',
         'guided_setup=radiocli setup',
-        `install_mpv=${mpvInstallCommand(platform, osRelease)}`,
-        `optional_ffplay=${ffplayInstallCommand(platform, osRelease)}`
+        `install_mpv=${mpvInstallCommand(platform, osRelease, process.env, options)}`,
+        `optional_ffplay=${ffplayInstallCommand(platform, osRelease, process.env, options)}`
     ];
     if (backendSet.has('mpv')) {
         return [
@@ -123,89 +131,3 @@ export function playbackBackendStatusLines(backends, platform = process.platform
         ...lines
     ];
 }
-export function mpvInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease()) {
-    if (platform === 'darwin') {
-        return 'brew install mpv';
-    }
-    if (platform === 'win32') {
-        return 'winget install --id shinchiro.mpv -e';
-    }
-    if (platform !== 'linux') {
-        return 'install mpv with your system package manager';
-    }
-    const ids = linuxReleaseIds(osRelease);
-    if (hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])) {
-        return 'sudo apt install mpv';
-    }
-    if (hasAny(ids, ['fedora', 'rhel', 'centos'])) {
-        return 'sudo dnf install mpv';
-    }
-    if (hasAny(ids, ['arch', 'manjaro'])) {
-        return 'sudo pacman -S mpv';
-    }
-    if (hasAny(ids, ['alpine'])) {
-        return 'sudo apk add mpv';
-    }
-    if (hasAny(ids, ['opensuse', 'suse'])) {
-        return 'sudo zypper install mpv';
-    }
-    return 'install mpv with your system package manager';
-}
-function ffplayInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease()) {
-    if (platform === 'darwin') {
-        return 'brew install ffmpeg';
-    }
-    if (platform === 'win32') {
-        return 'winget install --id Gyan.FFmpeg -e';
-    }
-    if (platform !== 'linux') {
-        return 'install FFmpeg with your system package manager';
-    }
-    const ids = linuxReleaseIds(osRelease);
-    if (hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])) {
-        return 'sudo apt install ffmpeg';
-    }
-    if (hasAny(ids, ['fedora', 'rhel', 'centos'])) {
-        return 'sudo dnf install ffmpeg';
-    }
-    if (hasAny(ids, ['arch', 'manjaro'])) {
-        return 'sudo pacman -S ffmpeg';
-    }
-    if (hasAny(ids, ['alpine'])) {
-        return 'sudo apk add ffmpeg';
-    }
-    if (hasAny(ids, ['opensuse', 'suse'])) {
-        return 'sudo zypper install ffmpeg';
-    }
-    return 'install FFmpeg with your system package manager';
-}
-function readLinuxOsRelease() {
-    if (process.platform !== 'linux' || !existsSync('/etc/os-release')) {
-        return '';
-    }
-    try {
-        return readFileSync('/etc/os-release', 'utf8');
-    }
-    catch {
-        return '';
-    }
-}
-function linuxReleaseIds(osRelease) {
-    const ids = new Set();
-    for (const line of osRelease.split('\n')) {
-        const match = /^(ID|ID_LIKE)=(.*)$/.exec(line);
-        if (!match) {
-            continue;
-        }
-        for (const value of match[2].replaceAll('"', '').split(/\s+/)) {
-            const normalized = value.trim().toLowerCase();
-            if (normalized) {
-                ids.add(normalized);
-            }
-        }
-    }
-    return ids;
-}
-function hasAny(values, candidates) {
-    return candidates.some(candidate => values.has(candidate));
-}

package/dist/player/command-diagnostics.js

@@ -1,9 +1,9 @@
 import { spawnSync } from 'node:child_process';
-import { resolveCommandDetails } from './command.js';
+import { resolveCommandDetails } from '../platform/executables.js';
 export function diagnoseCommand(command, overrides = {}) {
     const resolution = (overrides.resolve ?? resolveCommandDetails)(command);
     if (!resolution.path) {
-        return { ...resolution, launchable: false, version: null, error: 'not found' };
+        return { ...resolution, launchable: false, version: null, error: resolution.error ?? 'not found' };
     }
     const execute = overrides.execute ?? ((path, args, options) => spawnSync(path, args, options));
     const result = execute(resolution.path, ['--version'], {

package/dist/player/ffmpeg-input.js

@@ -0,0 +1,37 @@
+// FFmpeg releases in circulation do not propagate tls_verify to resources
+// opened by HLS/DASH/IMF demuxers. Restrict network fallbacks to self-contained
+// media; mpv supplies verified networking for multi-resource inputs.
+const mediaFormats = 'aac,ac3,aiff,amr,ape,asf,au,avi,caf,eac3,flac,flv,live_flv,matroska,webm,mov,mp4,m4a,3gp,3g2,mj2,mp3,mpeg,mpegts,nut,ogg,w64,wav,wv';
+export function ffmpegInputArguments(target, options = {}) {
+    const network = /^https?:\/\//i.test(target);
+    const plainHttp = options.plainHttp && /^http:\/\//i.test(target);
+    if (!network)
+        return ['-protocol_whitelist', 'file,crypto,data'];
+    const args = ['-format_whitelist', mediaFormats];
+    if (plainHttp)
+        args.push('-protocol_blacklist', 'https,tls');
+    else
+        args.push('-tls_verify', '1');
+    if (options.reconnect)
+        args.push('-reconnect', '1', '-reconnect_on_network_error', '1', '-reconnect_streamed', '1', '-reconnect_delay_max', '2');
+    return args;
+}
+/** First verify any HTTP -> HTTPS redirect. FFmpeg rejects the unused TLS
+ * option on ordinary HTTP media; retry only that exact failure, with TLS
+ * protocols blocked even if the server changes its redirect. */
+export function canRetryPlainHttp(target, diagnostic) {
+    return /^http:\/\//i.test(target) && /(?:^|[\r\n])Option tls_verify not found\.?\s*(?:[\r\n]|$)/.test(diagnostic);
+}
+export function ffmpegInputFailure(diagnostic) {
+    if (/not on whitelist|on blacklist/i.test(diagnostic))
+        return 'This input is unavailable with FFmpeg. Use a direct audio stream, or select mpv for local playback of HLS/DASH and other network playlists.';
+    return undefined;
+}
+export function ffmpegCertificateFailure(diagnostic) {
+    // Backends use different TLS libraries. Generic handshake/I/O errors can be
+    // transient; only specific certificate failures are permanent here.
+    if (/certificate (?:verify|verification) failed|peer certificate failed verification|certificate's owner does not match hostname|unable to verify peer certificate|invalid certificate chain|SNI or certificate check failed|Creating security context failed \(0x800903(?:25|27|28)\)/i.test(diagnostic)) {
+        return 'The stream certificate could not be verified. Choose a valid HTTPS stream or repair the native certificate configuration.';
+    }
+    return undefined;
+}

package/dist/player/mpv-desktop-media.js

@@ -0,0 +1,194 @@
+import { closeSync, constants, fstatSync, openSync, opendirSync, readSync, realpathSync, statSync } from 'node:fs';
+import { posix } from 'node:path';
+const maxConfigBytes = 256 * 1024;
+const maxScripts = 256;
+const unsupported = (reason) => ({ status: 'unsupported', args: [], reason });
+const compatible = (args, reason) => ({ status: 'compatible', args, reason });
+/**
+ * mpv-mpris 1.3 has no per-process opt-out. Replace directory autoload with its
+ * exact file list, omitting only the packaged plugin. mpv still reads its normal
+ * configuration and loads every unrelated script. Nothing is written to disk.
+ *
+ * Source contracts: mpv player/scripting.c and options/path.c; mpv-mpris Makefile.
+ * Configurations whose script-loading semantics cannot be preserved are left
+ * completely alone; the application media service must then remain disabled.
+ */
+export function planMpvDesktopMedia(options = {}) {
+    if ((options.platform ?? process.platform) !== 'linux')
+        return unsupported('Desktop mpv media integration is available on Linux.');
+    const env = options.env ?? process.env;
+    const executable = options.executable ?? env.RADIOCLI_MPV_PATH ?? '/usr/bin/mpv';
+    if (!options.configDirectories && !['/usr/bin/mpv', '/bin/mpv'].includes(executable)) {
+        return unsupported('Desktop media controls require the packaged mpv configuration layout; the custom mpv executable was left unchanged.');
+    }
+    try {
+        const directories = options.configDirectories ?? configDirectories(env);
+        let stockMprisPath = options.stockMprisPath ?? '/usr/lib/mpv-mpris/mpris.so';
+        try {
+            stockMprisPath = realpathSync(stockMprisPath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        let autoload = true;
+        let ambiguous = false;
+        // mpv loads encoding profiles first, then config/mpv.conf in each search
+        // directory. A profile with script options is deliberately not reinterpreted.
+        const files = [
+            ...directories.map(directory => posix.join(directory, 'encoding-profiles.conf')),
+            ...directories.flatMap(directory => ['config', 'mpv.conf'].map(file => posix.join(directory, file)))
+        ];
+        for (const file of files) {
+            const contents = readConfig(file);
+            if (contents === null)
+                continue;
+            let profile = false;
+            for (const raw of contents.split(/\r?\n/)) {
+                const line = raw.trim();
+                if (!line || line.startsWith('#'))
+                    continue;
+                if (line.startsWith('[')) {
+                    profile = !/^\[default\]\s*(?:#.*)?$/.test(line);
+                    continue;
+                }
+                // Includes and script lists can change startup script order or load
+                // another media plugin. Ordinary profiles remain intact; script options
+                // inside any profile are rejected even when that profile is inactive.
+                if (/^(?:--)?(?:include|config(?:-dir)?|use-filedir-conf|scripts?(?:-(?:add|append|clr|del|pre|set|toggle|remove))?)\s*(?:=|$)/i.test(line)) {
+                    ambiguous = true;
+                    continue;
+                }
+                if (/^(?:--)?(?:no-)?load-scripts\b/i.test(line)) {
+                    const setting = /^(?:--)?load-scripts\s*=\s*(yes|no)\s*(?:#.*)?$/i.exec(line);
+                    if (profile || !setting)
+                        ambiguous = true;
+                    else
+                        autoload = setting[1].toLowerCase() === 'yes';
+                }
+            }
+        }
+        if (ambiguous)
+            return unsupported('Custom mpv script, include, or profile directives require native media handling; mpv configuration and scripts were left unchanged.');
+        if (!autoload)
+            return compatible([], 'mpv directory scripts are disabled by the existing configuration.');
+        const scripts = [];
+        let omitted = 0;
+        for (const directory of directories) {
+            const entries = scriptFiles(posix.join(directory, 'scripts'));
+            for (const file of entries) {
+                if (scripts.length + omitted >= maxScripts)
+                    throw new Error('Too many mpv scripts to preserve within the bounded desktop media check.');
+                const actual = realpathSync(file);
+                if (actual === stockMprisPath) {
+                    omitted++;
+                    continue;
+                }
+                if (/^(?:mpv[-_])?mpris(?:\.(?:so|lua|js))?$/i.test(posix.basename(file)) || /^(?:mpv[-_])?mpris(?:\.(?:so|lua|js))?$/i.test(posix.basename(actual))) {
+                    return unsupported('A custom mpv MPRIS plugin needs native media handling; mpv configuration and scripts were left unchanged.');
+                }
+                scripts.push(file);
+            }
+        }
+        if (!omitted)
+            return compatible([], 'No stock mpv media plugin needs suppression.');
+        return compatible(['--load-scripts=no', ...scripts.map(file => `--script=${file}`)], 'The stock mpv media plugin is omitted for this process; other scripts and configuration are preserved.');
+    }
+    catch {
+        return unsupported('mpv script configuration could not be safely inspected; native mpv behavior is preserved.');
+    }
+}
+function configDirectories(env) {
+    if (env.MPV_HOME !== undefined) {
+        if (!env.MPV_HOME)
+            return [];
+        return [absolute(env.MPV_HOME)];
+    }
+    const result = ['/etc/mpv'];
+    const home = env.HOME ? absolute(env.HOME) : null;
+    const modern = env.XDG_CONFIG_HOME?.startsWith('/') ? posix.join(absolute(env.XDG_CONFIG_HOME), 'mpv') : home ? posix.join(home, '.config', 'mpv') : null;
+    const legacy = home ? posix.join(home, '.mpv') : null;
+    if (legacy && isDirectory(legacy))
+        result.push(legacy);
+    if (modern && (modern !== legacy) && (!legacy || !isDirectory(legacy) || isDirectory(modern)))
+        result.push(modern);
+    return result;
+}
+function absolute(value) {
+    if (!posix.isAbsolute(value) || /[\0\r\n]/.test(value))
+        throw new Error('Ambiguous mpv configuration path.');
+    return posix.normalize(value);
+}
+function isDirectory(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+function readConfig(path) {
+    let descriptor;
+    try {
+        descriptor = openSync(path, constants.O_RDONLY | constants.O_NONBLOCK);
+        const info = fstatSync(descriptor);
+        if (!info.isFile() || info.size > maxConfigBytes)
+            throw new Error('Unbounded mpv configuration.');
+        const buffer = Buffer.alloc(maxConfigBytes + 1);
+        const size = readSync(descriptor, buffer, 0, buffer.length, 0);
+        if (size > maxConfigBytes)
+            throw new Error('Unbounded mpv configuration.');
+        return buffer.toString('utf8', 0, size);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+    finally {
+        if (descriptor !== undefined)
+            closeSync(descriptor);
+    }
+}
+function scriptFiles(directory) {
+    let handle;
+    try {
+        handle = opendirSync(directory);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+    const files = [];
+    let inspected = 0;
+    try {
+        for (let entry = handle.readSync(); entry; entry = handle.readSync()) {
+            if (++inspected > 1024 || files.length >= maxScripts)
+                throw new Error('Unbounded mpv script directory.');
+            if (entry.name.startsWith('.'))
+                continue;
+            const path = posix.join(directory, entry.name);
+            let info;
+            try {
+                info = statSync(path);
+            }
+            catch (error) {
+                if (error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            if (info.isFile() || info.isDirectory())
+                files.push(path);
+        }
+    }
+    finally {
+        handle.closeSync();
+    }
+    // Use stable ASCII ordering for explicit scripts, without locale collation.
+    // Native mpv autoload order is not a reliable script dependency contract.
+    const fold = (value) => Buffer.from(value.replace(/[A-Z]/g, letter => letter.toLowerCase()));
+    return files.sort((left, right) => Buffer.compare(fold(left), fold(right)));
+}

package/dist/player/mpv-ipc-client.js

@@ -14,12 +14,25 @@ export class MpvIpcClient {
     connecting = null;
     pending = new Map();
     buffer = '';
+    bufferBytes = 0;
+    bufferScanFrom = 0;
     nextRequestId = 1;
     closed = false;
+    connectedOnce = false;
+    observers = new Map();
+    eventListeners = new Set();
     constructor(path, timeoutMs = 1000) {
         this.path = path;
         this.timeoutMs = timeoutMs;
     }
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    async observe(id, property) {
+        this.observers.set(id, property);
+        await this.query({ command: ['observe_property', id, property] });
+    }
     async query(payload) {
         if (this.closed) {
             throw new Error('mpv IPC client is closed.');
@@ -54,6 +67,8 @@ export class MpvIpcClient {
             return;
         }
         this.closed = true;
+        this.eventListeners.clear();
+        this.observers.clear();
         this.rejectPending(reason);
         this.socket?.destroy();
         this.connectingSocket?.destroy();
@@ -61,6 +76,8 @@ export class MpvIpcClient {
         this.connectingSocket = null;
         this.connecting = null;
         this.buffer = '';
+        this.bufferBytes = 0;
+        this.bufferScanFrom = 0;
     }
     connect() {
         if (this.socket && !this.socket.destroyed) {
@@ -102,10 +119,19 @@ export class MpvIpcClient {
                 this.socket = socket;
                 this.connectingSocket = null;
                 this.buffer = '';
-                socket.on('data', chunk => this.consume(chunk.toString('utf8')));
+                this.bufferBytes = 0;
+                this.bufferScanFrom = 0;
+                socket.setEncoding('utf8');
+                socket.on('data', chunk => { if (this.socket === socket)
+                    this.consume(String(chunk)); });
                 socket.on('error', error => this.dropSocket(socket, error));
                 socket.on('close', () => this.dropSocket(socket, new Error('mpv IPC connection closed.')));
                 resolve(socket);
+                if (this.connectedOnce) {
+                    for (const [id, property] of this.observers)
+                        void this.query({ command: ['observe_property', id, property] }).catch(() => undefined);
+                }
+                this.connectedOnce = true;
             };
             socket.once('error', failConnection);
             socket.once('close', closeBeforeConnection);
@@ -126,10 +152,20 @@ export class MpvIpcClient {
     }
     consume(chunk) {
         this.buffer += chunk;
-        let newlineIndex = this.buffer.indexOf('\n');
+        this.bufferBytes += Buffer.byteLength(chunk);
+        if (this.bufferBytes > 4 * 1024 * 1024) {
+            const socket = this.socket;
+            if (socket) {
+                this.dropSocket(socket, new Error('mpv IPC message exceeds 4 MiB.'));
+                socket.destroy();
+            }
+            return;
+        }
+        let newlineIndex = this.buffer.indexOf('\n', this.bufferScanFrom);
         while (newlineIndex !== -1) {
             const line = this.buffer.slice(0, newlineIndex);
             this.buffer = this.buffer.slice(newlineIndex + 1);
+            this.bufferBytes -= Buffer.byteLength(line) + 1;
             newlineIndex = this.buffer.indexOf('\n');
             if (!line.trim()) {
                 continue;
@@ -141,7 +177,18 @@ export class MpvIpcClient {
             catch {
                 continue;
             }
+            if (!response || typeof response !== 'object' || Array.isArray(response))
+                continue;
             if (typeof response.request_id !== 'number' || !this.pending.has(response.request_id)) {
+                const event = response;
+                if (typeof event.event === 'string') {
+                    for (const listener of this.eventListeners) {
+                        try {
+                            listener(event);
+                        }
+                        catch { /* Isolate event consumers. */ }
+                    }
+                }
                 continue;
             }
             if (response.error && response.error !== 'success') {
@@ -151,6 +198,7 @@ export class MpvIpcClient {
                 this.settleRequest(response.request_id, pending => pending.resolve(response.data));
             }
         }
+        this.bufferScanFrom = this.buffer.length;
     }
     dropSocket(socket, error) {
         if (this.socket !== socket) {
@@ -158,6 +206,8 @@ export class MpvIpcClient {
         }
         this.socket = null;
         this.buffer = '';
+        this.bufferBytes = 0;
+        this.bufferScanFrom = 0;
         this.rejectPending(error);
     }
     rejectPending(error) {