@ciphore/radiocli 0.2.3 → 0.2.4

package/dist/platform/terminal.js

@@ -0,0 +1,63 @@
+/** Environment overrides affect this invocation, never the saved settings. */
+export function resolveTerminalCapabilities(env = process.env, evidence = {}) {
+    const dumb = env.TERM?.toLowerCase() === 'dumb';
+    const screenReader = evidence.screenReader === true || env.INK_SCREEN_READER === 'true' || flag(env.RADIOCLI_SCREEN_READER) === true;
+    const interactive = evidence.isTTY !== false && !dumb;
+    const asciiOverride = flag(env.RADIOCLI_ASCII);
+    const unicodeOverride = flag(env.RADIOCLI_UNICODE);
+    const locale = [env.LC_ALL, env.LC_CTYPE, env.LANG].find(value => value?.trim())?.trim();
+    // An explicit ASCII request wins when both overrides are enabled. A bare
+    // C/POSIX locale is a known constraint; SSH and missing locale data are not.
+    const unicode = dumb ? false
+        : asciiOverride === true ? false
+            : unicodeOverride === true ? true
+                : asciiOverride === false ? true
+                    : unicodeOverride === false ? false
+                        : locale === 'C' || locale === 'POSIX' ? false : !evidence.asciiMode;
+    const colorLevel = dumb || screenReader || Boolean(env.NO_COLOR) ? 0 : resolveColorLevel(env, evidence);
+    return {
+        unicode,
+        colorLevel,
+        screenReader,
+        reduceMotion: Boolean(evidence.reduceMotion) || !interactive || screenReader || env.RADIOCLI_DISABLE_ANIMATION === '1' || env.RADIO_ATLAS_DISABLE_ANIMATION === '1',
+        interactive
+    };
+}
+function resolveColorLevel(env, evidence) {
+    const forced = env.FORCE_COLOR;
+    if (forced === '0' || forced === 'false')
+        return 0;
+    if (forced === '2')
+        return 2;
+    if (forced === '3')
+        return 3;
+    if (forced === '' || forced === '1' || forced === 'true')
+        return 1;
+    if (evidence.isTTY === false)
+        return 0;
+    // COLORTERM=truecolor/24bit and direct-color TERM values are explicit
+    // capability declarations. Some terminals expose those declarations while
+    // Node's getColorDepth() still reports 8 bits, so honor them before the
+    // conservative stream probe to avoid silently quantizing RGB themes.
+    if (/^(truecolor|24bit)$/i.test(env.COLORTERM ?? '') || /(?:direct|truecolor)/i.test(env.TERM ?? ''))
+        return 3;
+    if (evidence.colorDepth !== undefined) {
+        return evidence.colorDepth <= 1 ? 0 : evidence.colorDepth <= 4 ? 1 : evidence.colorDepth <= 8 ? 2 : 3;
+    }
+    if (/256color/i.test(env.TERM ?? ''))
+        return 2;
+    if (env.TERM)
+        return 1;
+    // Preserve the existing rich display unless the environment supplies a
+    // concrete constraint. Native callers can pass stdout.getColorDepth().
+    return 3;
+}
+function flag(value) {
+    if (value === undefined)
+        return undefined;
+    if (/^(1|true|yes|on)$/i.test(value))
+        return true;
+    if (/^(0|false|no|off)$/i.test(value))
+        return false;
+    return undefined;
+}

package/dist/platform/terminals.js

@@ -0,0 +1,203 @@
+import { spawn } from 'node:child_process';
+import { posix, win32 } from 'node:path';
+import { resolveCommandDetails } from './executables.js';
+import { identifyPlatform, nativeAdapters } from './runtime.js';
+import { powershellCommand } from './shell.js';
+import { launchEnvironment, nodeLaunchCommand, waitForLaunch } from './launch-command.js';
+const unixTerminals = [
+    { name: 'ghostty', args: ['-e'] }, { name: 'wezterm', args: ['start', '--always-new-process', '--'] },
+    { name: 'kitty', args: ['-e'] }, { name: 'gnome-terminal', args: ['--'] }, { name: 'konsole', args: ['-e'] },
+    { name: 'xfce4-terminal', args: ['-x'] }, { name: 'x-terminal-emulator', args: ['-e'], shell: true },
+    { name: 'alacritty', args: ['-e'] }, { name: 'foot', args: ['--'], display: 'wayland' },
+    { name: 'mate-terminal', args: ['-x'] }, { name: 'qterminal', args: ['-e'], shell: true },
+    { name: 'terminator', args: ['-x'] }, { name: 'tilix', args: ['-e'] },
+    { name: 'xterm', args: ['-e'], display: 'x11' }, { name: 'uxterm', args: ['-e'], display: 'x11' }
+];
+const macTerminals = ['darwin:apple-terminal', 'darwin:iterm', 'darwin:wezterm', 'darwin:ghostty', 'darwin:kitty'];
+export function detectGraphicalTerminal(platform = process.platform, env = process.env, resolve = resolver(platform, env)) {
+    const host = identifyPlatform({ platform, env });
+    const adapter = nativeAdapters(host).terminal;
+    const unsupported = `${host.id === 'unknown' ? platform : host.id}:unsupported`;
+    const configured = env.RADIOCLI_ALARM_TERMINAL?.trim();
+    if (adapter === 'macos') {
+        if (configured && macTerminals.includes(configured))
+            return configured;
+        const program = `${env.TERM_PROGRAM ?? ''} ${env.__CFBundleIdentifier ?? ''}`.toLowerCase();
+        for (const name of ['iterm', 'wezterm', 'ghostty', 'kitty'])
+            if (program.includes(name))
+                return `darwin:${name}`;
+        return 'darwin:apple-terminal';
+    }
+    if (adapter === 'windows') {
+        if (configured === 'win32:windows-terminal' || configured === 'win32:console')
+            return configured;
+        return env.WT_SESSION ? 'win32:windows-terminal' : 'win32:console';
+    }
+    if (adapter !== 'unix' || !hasDisplay(env))
+        return unsupported;
+    if (configured) {
+        const separator = configured.indexOf(':');
+        const prefix = separator < 0 ? '' : configured.slice(0, separator);
+        if (prefix === host.id || prefix === 'linux') {
+            const path = resolveUnixTerminal(configured.slice(separator + 1), env, resolve);
+            return path ? `${prefix}:${path}` : unsupported;
+        }
+    }
+    const requested = env.TERMINAL?.trim() || env.TERM_PROGRAM?.trim();
+    const selected = requested && resolveUnixTerminal(requested, env, resolve);
+    if (selected)
+        return `${host.id}:${selected}`;
+    for (const terminal of unixTerminals) {
+        const path = resolveUnixTerminal(terminal.name, env, resolve);
+        if (path)
+            return `${host.id}:${path}`;
+    }
+    return unsupported;
+}
+export function createTerminalLaunch(options) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const resolve = options.resolve ?? resolver(platform, env);
+    const terminal = detectGraphicalTerminal(platform, env, resolve);
+    const values = [options.nodePath, ...options.args];
+    if (values.some(value => value.includes('\0')))
+        throw new Error('Terminal command values cannot contain NUL bytes.');
+    const environment = launchEnvironment(env, { platform });
+    const direct = nodeLaunchCommand(options.nodePath, options.args, environment);
+    if (terminal.endsWith(':unsupported')) {
+        if (nativeAdapters(identifyPlatform({ platform, env })).terminal === 'unix' && !hasDisplay(env))
+            throw new Error('No graphical desktop session is available: DISPLAY and WAYLAND_DISPLAY are unset. Open radiocli manually for controls.');
+        throw new Error('No supported installed graphical terminal was found. Open radiocli manually for controls.');
+    }
+    if (terminal === 'darwin:apple-terminal' || terminal === 'darwin:iterm') {
+        const command = `${direct.map(shellQuote).join(' ')}${options.closeOnExit ? '; exit' : ''}`;
+        return { terminal, command: '/usr/bin/osascript', args: terminal === 'darwin:apple-terminal' ? appleTerminalScript(command) : iTermScript(command) };
+    }
+    if (terminal === 'darwin:wezterm')
+        return { terminal, command: '/usr/bin/open', args: ['-na', 'WezTerm', '--args', 'start', '--always-new-process', '--', ...direct] };
+    if (terminal === 'darwin:ghostty')
+        return { terminal, command: '/usr/bin/open', args: ['-na', 'Ghostty', '--args', '-e', ...direct] };
+    if (terminal === 'darwin:kitty')
+        return { terminal, command: '/usr/bin/open', args: ['-na', 'kitty', '--args', '--detach', ...direct] };
+    if (terminal.startsWith('win32:')) {
+        const systemRoot = env.SystemRoot ?? env.WINDIR;
+        const powershell = resolve('powershell.exe') ?? (systemRoot ? resolve(win32.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe')) : undefined) ?? resolve('pwsh.exe');
+        if (!powershell)
+            throw new Error('PowerShell is unavailable; a RadioCLI terminal cannot be requested.');
+        // PowerShell 5 does not preserve arbitrary native argv quoting. Only a
+        // fixed quote-free Node program and encoded JSON cross that boundary.
+        const args = powershellCommand(direct, {}, { keepOpen: !options.closeOnExit });
+        if (terminal === 'win32:console')
+            return { terminal, command: powershell, ...newWindowsConsole(powershell, args) };
+        const wt = resolve('wt.exe') ?? (env.LOCALAPPDATA ? resolve(win32.join(env.LOCALAPPDATA, 'Microsoft', 'WindowsApps', 'wt.exe')) : undefined);
+        if (!wt)
+            throw new Error('Windows Terminal is unavailable; the saved terminal cannot be requested.');
+        return { terminal, command: wt, args: ['-w', 'new', 'new-tab', '--title', options.title ?? 'RadioCLI', powershell, ...args] };
+    }
+    const executable = terminal.slice(terminal.indexOf(':') + 1);
+    const spec = unixTerminals.find(item => item.name === posix.basename(executable));
+    if (!spec)
+        throw new Error('The saved graphical terminal is unsupported.');
+    // QTerminal reparses only its first -e argument, then appends argv literally.
+    // The alternatives alias can select QTerminal too, so both use the fixed
+    // POSIX shell boundary. This also preserves argv for ordinary -e terminals.
+    if (spec.shell) {
+        const sh = resolve('/bin/sh');
+        if (!sh)
+            throw new Error('The POSIX shell required by this terminal is unavailable.');
+        return { terminal, command: executable, args: [...spec.args, sh, '-c', direct.map(shellQuote).join(' ')] };
+    }
+    return { terminal, command: executable, args: [...spec.args, ...direct] };
+}
+/** Request acceptance is separate from the caller's TUI/session verification. */
+export async function launchTerminalCommand(options) {
+    const plan = createTerminalLaunch(options);
+    // PowerShell can exit without executing its script under DETACHED_PROCESS.
+    // Keep this short-lived bootstrap attached until it creates the independent
+    // console. The new console, not its bootstrap, owns the interactive handles.
+    // https://github.com/nodejs/node/issues/51018
+    const consoleBootstrap = plan.terminal === 'win32:console';
+    const child = (options.spawn ?? spawn)(plan.command, plan.args, { env: { ...(options.env ?? process.env), ...plan.environment }, detached: !consoleBootstrap, stdio: 'ignore', windowsHide: consoleBootstrap });
+    await waitForLaunch(child, { waitForExit: consoleBootstrap });
+    return plan.terminal;
+}
+function resolver(platform, env) { return command => resolveCommandDetails(command, { platform, env }).path ?? undefined; }
+function hasDisplay(env) { return Boolean(env.DISPLAY?.trim() || env.WAYLAND_DISPLAY?.trim()); }
+function resolveUnixTerminal(input, env, resolve) {
+    const spec = unixTerminals.find(item => item.name === posix.basename(input).toLowerCase());
+    if (!spec || spec.display === 'x11' && !env.DISPLAY?.trim() || spec.display === 'wayland' && !env.WAYLAND_DISPLAY?.trim())
+        return undefined;
+    const path = resolve(input);
+    return path && unixTerminals.some(item => item.name === posix.basename(path)) ? path : undefined;
+}
+function shellQuote(value) { return `'${value.replaceAll("'", `'\\''`)}'`; }
+function newWindowsConsole(powershell, args) {
+    const key = 'RADIOCLI_WINDOWS_CONSOLE_COMMAND';
+    // The transient launcher has NUL stdio. CreateProcessW explicitly creates
+    // new console buffers without inheriting those handles; STARTF_USESTDHANDLES
+    // must stay unset. ShellExecute-based Start-Process does not provide this
+    // handle contract. Only fixed flags and encoded data enter the argument string.
+    // https://learn.microsoft.com/en-us/windows/console/creation-of-a-console
+    // https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createprocessw
+    const native = String.raw `
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+using System.Text;
+public static class RadioCliConsole {
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  private struct StartupInfo {
+    public uint cb;
+    public string lpReserved, lpDesktop, lpTitle;
+    public uint dwX, dwY, dwXSize, dwYSize, dwXCountChars, dwYCountChars, dwFillAttribute, dwFlags;
+    public short wShowWindow, cbReserved2;
+    public IntPtr lpReserved2, hStdInput, hStdOutput, hStdError;
+  }
+  [StructLayout(LayoutKind.Sequential)]
+  private struct ProcessInformation {
+    public IntPtr hProcess, hThread;
+    public uint dwProcessId, dwThreadId;
+  }
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
+  [return: MarshalAs(UnmanagedType.Bool)]
+  private static extern bool CreateProcessW(string application, StringBuilder commandLine,
+    IntPtr processAttributes, IntPtr threadAttributes, [MarshalAs(UnmanagedType.Bool)] bool inheritHandles,
+    uint creationFlags, IntPtr environment, string currentDirectory, ref StartupInfo startup,
+    out ProcessInformation process);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  [return: MarshalAs(UnmanagedType.Bool)]
+  private static extern bool CloseHandle(IntPtr handle);
+  public static void Launch(string application, string arguments) {
+    var commandLine = new StringBuilder("\"" + application + "\" " + arguments);
+    if (commandLine.Length >= 32767) throw new ArgumentException("The Windows console command exceeds the native command-line limit.");
+    var startup = new StartupInfo();
+    startup.cb = (uint)Marshal.SizeOf(typeof(StartupInfo));
+    startup.dwFlags = 0x00000001; // STARTF_USESHOWWINDOW only; no inherited standard handles.
+    startup.wShowWindow = 1; // SW_SHOWNORMAL
+    ProcessInformation process;
+    if (!CreateProcessW(application, commandLine, IntPtr.Zero, IntPtr.Zero, false,
+      0x00000010, IntPtr.Zero, null, ref startup, out process)) { // CREATE_NEW_CONSOLE
+      throw new Win32Exception(Marshal.GetLastWin32Error());
+    }
+    CloseHandle(process.hThread);
+    CloseHandle(process.hProcess);
+  }
+}`;
+    const script = [
+        "$ErrorActionPreference='Stop'",
+        "$ProgressPreference='SilentlyContinue'",
+        `$radiocliConsole=[Environment]::GetEnvironmentVariable('${key}','Process') | ConvertFrom-Json`,
+        `[Environment]::SetEnvironmentVariable('${key}',$null,'Process')`,
+        `Add-Type -TypeDefinition '${native.replaceAll("'", "''")}'`,
+        "[RadioCliConsole]::Launch([string]$radiocliConsole.command, [string]::Join(' ', [string[]]$radiocliConsole.args))"
+    ].join(';');
+    // Only this short-lived outer process needs the handoff. Encoding the inner
+    // PowerShell command again exceeds Windows' command-line limit for ordinary
+    // deep install paths. Clear the private variable before creating the console.
+    return {
+        args: ['-NoLogo', '-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')],
+        environment: { [key]: JSON.stringify({ command: powershell, args }) }
+    };
+}
+function appleTerminalScript(command) { return ['-e', 'on run argv', '-e', 'tell application "Terminal"', '-e', 'activate', '-e', 'do script (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }
+function iTermScript(command) { return ['-e', 'on run argv', '-e', 'tell application "iTerm"', '-e', 'activate', '-e', 'set w to (create window with default profile)', '-e', 'tell current session of w to write text (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }

package/dist/player/airplay-discovery.js

@@ -1,13 +1,15 @@
 import { spawn } from 'node:child_process';
 import { lookup } from 'node:dns/promises';
 import { networkInterfaces } from 'node:os';
-import { commandExists } from './command.js';
+import { commandExists } from '../platform/executables.js';
+import { networkPolicy } from '../platform/network.js';
+import { identifyPlatform, nativeAdapters } from '../platform/runtime.js';
 const defaultTimeoutMs = 2500;
 const defaultMaxDevices = 12;
 const defaultLookupConcurrency = 4;
 const defaultMaxOutputBytes = 64 * 1024;
 export async function discoverAirPlayDevices({ platform = process.platform, timeoutMs = defaultTimeoutMs, maxDevices = defaultMaxDevices, lookupConcurrency = defaultLookupConcurrency, maxOutputBytes = defaultMaxOutputBytes } = {}) {
-    if (platform !== 'darwin' || !commandExists('dns-sd')) {
+    if (networkPolicy().offline || !nativeAdapters(identifyPlatform({ platform })).airPlay || !commandExists('dns-sd')) {
         return [];
     }
     const browseOutput = await runDnsSd(['-B', '_raop._tcp', 'local'], timeoutMs, maxOutputBytes).catch(() => '');

package/dist/player/backend-install.js

@@ -1,14 +1,19 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { commandExists } from './command.js';
+import { ffplayInstallCommand, mpvInstallCommand } from '../platform/packages.js';
+import { identifyPlatform, nativeAdapters, readLinuxOsRelease } from '../platform/runtime.js';
+import { commandExists } from '../platform/executables.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 const airPlayMacOSOnlyMessage = 'AirPlay output is available only on macOS and is not supported on this operating system.';
+export function isAirPlayPlatformSupported(platform = process.platform) {
+    return nativeAdapters(identifyPlatform({ platform })).airPlay;
+}
 export function detectPlaybackBackends({ platform = process.platform, 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()) {
+    if (isAirPlayPlatformSupported(platform) && hasCommand('ffmpeg') && hasCommand('dns-sd') && hasAirPlaySender()) {
         backends.push('airplay');
     }
     return backends;
@@ -69,16 +74,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 +128,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/mpv-ipc-client.js

@@ -102,7 +102,8 @@ export class MpvIpcClient {
                 this.socket = socket;
                 this.connectingSocket = null;
                 this.buffer = '';
-                socket.on('data', chunk => this.consume(chunk.toString('utf8')));
+                socket.setEncoding('utf8');
+                socket.on('data', chunk => 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);