@ciphore/radiocli 0.2.3 → 0.2.5

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,223 @@
+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';
+import { identifyOmarchy } from './omarchy.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'];
+const omarchyTerminal = 'linux:omarchy-launch-tui';
+export function detectGraphicalTerminal(platform = process.platform, env = process.env, resolveCommand, omarchy) {
+    const resolve = resolveCommand ?? 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;
+    const nativeOmarchy = () => identifyOmarchy({ ...omarchy, platform, env, ...(resolveCommand ? { resolve } : {}) }).terminal.available;
+    if (configured === omarchyTerminal) {
+        if (nativeOmarchy())
+            return omarchyTerminal;
+    }
+    else 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}`;
+    if (nativeOmarchy())
+        return omarchyTerminal;
+    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, options.resolve, options.omarchy);
+    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] };
+    }
+    if (terminal === omarchyTerminal) {
+        if (!posix.isAbsolute(options.nodePath))
+            throw new Error('The Omarchy launcher requires an absolute Node executable path.');
+        const command = resolve('/usr/share/omarchy/bin/omarchy-launch-tui') ?? resolve('omarchy-launch-tui');
+        if (!command || !posix.isAbsolute(command) || /[\0\r\n]/.test(command))
+            throw new Error('The Omarchy TUI launcher is unavailable.');
+        return { terminal, command, args: ['--app-id=org.radiocli.RadioCLI', ...direct] };
+    }
+    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 });
+    // The console bootstrap compiles a small Win32 bridge with Add-Type. Cold
+    // PowerShell/.NET startup on ARM64 needs more time than ordinary launchers.
+    await waitForLaunch(child, { waitForExit: consoleBootstrap, exitTimeoutMs: consoleBootstrap ? 30_000 : undefined });
+    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,26 +1,57 @@
-import { spawn } from 'node:child_process';
+import { isIP } from 'node:net';
 import { lookup } from 'node:dns/promises';
 import { networkInterfaces } from 'node:os';
-import { commandExists } from './command.js';
+import { resolveCommandDetails } from '../platform/executables.js';
+import { networkPolicy } from '../platform/network.js';
+import { isAirPlayPlatformSupported } from './backend-install.js';
+import { probeAirPlayReadiness } from './airplay-readiness.js';
+import { runAirPlayCommand } from './airplay-process.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')) {
+export async function discoverAirPlayDevices({ platform = process.platform, env = process.env, release, resolve = command => resolveCommandDetails(command, { platform, env }).path ?? undefined, hasCommand = command => Boolean(resolve(command)), run = runAirPlayCommand, readiness = probeAirPlayReadiness, timeoutMs = defaultTimeoutMs, maxDevices = defaultMaxDevices, lookupConcurrency = defaultLookupConcurrency, maxOutputBytes = defaultMaxOutputBytes } = {}) {
+    if (networkPolicy(env).offline || !isAirPlayPlatformSupported(platform, env, release)) {
         return [];
     }
-    const browseOutput = await runDnsSd(['-B', '_raop._tcp', 'local'], timeoutMs, maxOutputBytes).catch(() => '');
+    const tool = platform === 'linux' ? 'avahi-browse' : 'dns-sd';
+    const executable = hasCommand(tool) ? resolve(tool) : undefined;
+    if (!executable) {
+        if (platform === 'linux')
+            throw new Error('AirPlay discovery requires avahi-browse. Run radiocli doctor.');
+        return [];
+    }
+    timeoutMs = Math.min(defaultTimeoutMs, Math.max(1, timeoutMs));
+    maxOutputBytes = Math.min(defaultMaxOutputBytes, Math.max(1, maxOutputBytes));
+    maxDevices = Math.min(defaultMaxDevices, Math.max(0, Math.floor(maxDevices)));
+    if (platform === 'linux') {
+        const deadline = Date.now() + timeoutMs;
+        const health = await readiness({ platform, env, release, resolve, hasCommand, run });
+        if (!health.ready)
+            throw new Error(health.message);
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            throw new Error('AirPlay readiness check timed out. Run radiocli doctor.');
+        const result = await run(executable, ['--parsable', '--resolve', '--terminate', '--no-db-lookup', '_raop._tcp'], remaining, maxOutputBytes, { env });
+        if (result.code !== 0 && !result.timedOut && !result.truncated)
+            throw new Error('Avahi discovery failed. Check that the Avahi service is running with radiocli doctor.');
+        return parseAvahiBrowseOutput(result.output, maxDevices);
+    }
+    const browseOutput = await run(executable, ['-B', '_raop._tcp', 'local'], timeoutMs, maxOutputBytes, { env }).then(result => result.output).catch(() => '');
     const instances = parseRaopBrowseOutput(browseOutput).slice(0, Math.max(0, maxDevices));
     const devices = await mapWithConcurrency(instances, Math.max(1, lookupConcurrency), async (instance) => {
-        const lookupOutput = await runDnsSd(['-L', instance, '_raop._tcp', 'local'], timeoutMs, maxOutputBytes).catch(() => '');
+        const lookupOutput = await run(executable, ['-L', instance, '_raop._tcp', 'local'], timeoutMs, maxOutputBytes, { env }).then(result => result.output).catch(() => '');
         const device = parseRaopLookupOutput(instance, lookupOutput);
-        return device ? enrichAirPlayDeviceHost(device) : null;
+        return device ? enrichAirPlayDeviceHost(device, timeoutMs) : null;
     });
     return devices.filter((device) => Boolean(device));
 }
-async function enrichAirPlayDeviceHost(device) {
-    const addresses = await lookup(device.host, { all: true, family: 4 }).catch(() => []);
+async function enrichAirPlayDeviceHost(device, timeoutMs) {
+    let timer;
+    const addresses = await Promise.race([
+        lookup(device.host, { all: true, family: 4 }).catch(() => []),
+        new Promise(resolve => { timer = setTimeout(() => resolve([]), timeoutMs); })
+    ]).finally(() => clearTimeout(timer));
     if (addresses.length === 0) {
         return device;
     }
@@ -60,6 +91,82 @@ export function parseRaopBrowseOutput(output) {
     }
     return [...instances];
 }
+/** avahi-browse -pr emits resolved IPv4 and IPv6 records separately. The
+ * bundled sender uses udp4, so an IPv6-only record is deliberately not offered. */
+export function parseAvahiBrowseOutput(output, maxDevices = defaultMaxDevices) {
+    const devices = new Map();
+    const local = localIpv4Addresses();
+    for (const line of output.slice(0, defaultMaxOutputBytes).split('\n')) {
+        const fields = avahiFields(line);
+        if (fields.length !== 10 || fields[0] !== '=' || fields[2] !== 'IPv4' || fields[4] !== '_raop._tcp' || fields[5] !== 'local')
+            continue;
+        const host = fields[7];
+        const port = Number(fields[8]);
+        if (isIP(host) !== 4 || host === '0.0.0.0' || Number(host.split('.')[0]) >= 224 || !/^\d+$/.test(fields[8]) || port < 1 || port > 65535)
+            continue;
+        const id = sanitizeDnsSdText(unescapeDnsSdName(fields[3]), 256);
+        if (!id)
+            continue;
+        const txt = avahiTxt(fields[9]);
+        if (!txt)
+            continue;
+        const values = txtRecordMap(txt);
+        const sf = Number.parseInt((values.get('sf') ?? '0').replace(/^0x/i, ''), 16) || 0;
+        const device = {
+            id, name: displayNameForRaopInstance(id), host, port, txt,
+            local: local.has(host),
+            requiresPassword: values.get('pw')?.toLowerCase() === 'true' || (sf !== 0 && sf !== 4),
+            airplay2: Boolean(values.get('pk') || values.get('vv') === '2' || values.get('et')?.split(',').some(value => ['3', '4', '5'].includes(value)))
+        };
+        const prior = devices.get(id);
+        if (!prior || (isLoopbackAddress(prior.host) && !isLoopbackAddress(host)))
+            devices.set(id, device);
+    }
+    return [...devices.values()].slice(0, Math.min(defaultMaxDevices, Math.max(0, Math.floor(maxDevices))));
+}
+function avahiFields(line) {
+    const fields = [];
+    let start = 0;
+    for (let index = 0; index < line.length && fields.length < 9; index += 1) {
+        if (line[index] === '\\') {
+            index += 1;
+            continue;
+        }
+        if (line[index] === ';') {
+            fields.push(line.slice(start, index));
+            start = index + 1;
+        }
+    }
+    fields.push(line.slice(start));
+    return fields;
+}
+function avahiTxt(value) {
+    const entries = [];
+    let index = 0;
+    while (index < value.length) {
+        while (/\s/.test(value[index] ?? '') && index < value.length)
+            index += 1;
+        if (index === value.length)
+            break;
+        if (value[index] !== '"' || entries.length === 64)
+            return null;
+        const start = ++index;
+        while (index < value.length && value[index] !== '"') {
+            if (value[index] === '\\')
+                index += 1;
+            index += 1;
+        }
+        if (index === value.length)
+            return null;
+        const entry = sanitizeDnsSdText(unescapeDnsSdName(value.slice(start, index)), 512);
+        if (entry)
+            entries.push(entry);
+        index += 1;
+        if (index < value.length && !/\s/.test(value[index]))
+            return null;
+    }
+    return entries;
+}
 export function parseRaopLookupOutput(instance, output) {
     const reachable = output.match(/ can be reached at (.+?)\.?:(\d+) \(interface \d+\)/);
     if (!reachable?.[1] || !reachable[2]) {
@@ -74,20 +181,20 @@ export function parseRaopLookupOutput(instance, output) {
     const txtLine = output
         .split('\n')
         .map(line => line.trim())
-        .find(line => /\bcn=/.test(line) || /\bsf=/.test(line) || /\bpk=/.test(line));
+        .find(line => /\b(?:cn|sf|pk|pw)=/.test(line));
     const txt = txtLine
         ? txtLine.split(/\s+/).map(entry => sanitizeDnsSdText(entry, 512)).filter(Boolean).slice(0, 64)
         : [];
     const txtMap = txtRecordMap(txt);
     const sf = txtMap.get('sf');
-    const sfValue = sf ? Number.parseInt(sf.replace(/^0x/i, ''), 16) : 0;
+    const sfValue = sf ? Number.parseInt(sf.replace(/^0x/i, ''), 16) || 0 : 0;
     return {
         id,
         name: displayNameForRaopInstance(id),
         host,
         port,
         txt,
-        requiresPassword: sfValue !== 0 && sfValue !== 0x4,
+        requiresPassword: txtMap.get('pw')?.toLowerCase() === 'true' || (sfValue !== 0 && sfValue !== 0x4),
         airplay2: Boolean(txtMap.get('pk') || txtMap.get('vv') === '2' || txtMap.get('et')?.split(',').some(value => ['3', '4', '5'].includes(value)))
     };
 }
@@ -107,7 +214,32 @@ function txtRecordMap(txt) {
     return map;
 }
 function unescapeDnsSdName(value) {
-    return value.replace(/\\(\d{3})/g, (_match, code) => String.fromCharCode(Number(code)));
+    const bytes = [];
+    for (let index = 0; index < value.length;) {
+        const match = /^\\(\d{3})/.exec(value.slice(index));
+        if (match) {
+            const byte = Number(match[1]);
+            if (byte > 255)
+                return '';
+            bytes.push(byte);
+            index += 4;
+        }
+        else if (value[index] === '\\' && index + 1 < value.length) {
+            bytes.push(...Buffer.from(value[index + 1]));
+            index += 2;
+        }
+        else {
+            const character = String.fromCodePoint(value.codePointAt(index));
+            bytes.push(...Buffer.from(character));
+            index += character.length;
+        }
+    }
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(Uint8Array.from(bytes));
+    }
+    catch {
+        return '';
+    }
 }
 function normalizeHost(value) {
     const host = sanitizeDnsSdText(unescapeDnsSdName(value), 253).replace(/\.$/, '');
@@ -124,53 +256,6 @@ function sanitizeDnsSdText(value, maxBytes) {
     }
     return cleaned.trim();
 }
-function runDnsSd(args, timeoutMs, maxOutputBytes) {
-    return new Promise(resolve => {
-        const child = spawn('dns-sd', args, { stdio: ['ignore', 'pipe', 'pipe'] });
-        let output = '';
-        let killedForLimit = false;
-        let settled = false;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            clearTimeout(forceTimer);
-            resolve(output);
-        };
-        const timer = setTimeout(() => {
-            child.kill('SIGTERM');
-            setTimeout(() => {
-                if (child.exitCode === null)
-                    child.kill('SIGKILL');
-            }, 250).unref();
-        }, timeoutMs);
-        const forceTimer = setTimeout(finish, timeoutMs + 750);
-        const appendOutput = (chunk) => {
-            if (Buffer.byteLength(output, 'utf8') >= maxOutputBytes) {
-                if (!killedForLimit) {
-                    killedForLimit = true;
-                    child.kill('SIGTERM');
-                }
-                return;
-            }
-            const remaining = maxOutputBytes - Buffer.byteLength(output, 'utf8');
-            output += chunk.toString('utf8').slice(0, remaining);
-        };
-        child.stdout.on('data', chunk => {
-            appendOutput(chunk);
-        });
-        child.stderr.on('data', chunk => {
-            appendOutput(chunk);
-        });
-        child.once('error', () => {
-            finish();
-        });
-        child.once('exit', () => {
-            finish();
-        });
-    });
-}
 async function mapWithConcurrency(items, concurrency, map) {
     const results = [];
     let nextIndex = 0;

package/dist/player/airplay-policy.js

@@ -0,0 +1,15 @@
+import { identifyPlatform, nativeAdapters } from '../platform/runtime.js';
+const airPlayUnsupportedMessage = 'AirPlay output is experimental on macOS and native Linux and is not supported in this environment.';
+const linuxAirPlayDisabledMessage = 'Experimental Linux AirPlay is disabled for this library. Run radiocli setup --airplay to enable it.';
+export const airPlaySetupRequiredMessage = 'AirPlay setup required. Run radiocli setup --airplay, then radiocli doctor.';
+export function isAirPlayPlatformSupported(platform = process.platform, env, release) {
+    const native = platform === process.platform;
+    return nativeAdapters(identifyPlatform({ platform, env: env ?? (native ? process.env : {}), release: release ?? (native ? undefined : '') })).airPlay;
+}
+/** Application consent is independent of optional dependencies and receiver reachability. */
+export function airPlayPolicy(settings = {}, { platform = process.platform, env, release } = {}) {
+    const eligible = isAirPlayPlatformSupported(platform, env, release);
+    const enabled = eligible && (platform === 'darwin' || settings.linuxAirPlayEnabled === true);
+    const state = !eligible ? 'unsupported' : !enabled ? 'disabled' : 'enabled';
+    return { eligible, enabled, state, message: !eligible ? airPlayUnsupportedMessage : !enabled ? linuxAirPlayDisabledMessage : 'Experimental AirPlay is enabled.' };
+}

package/dist/player/airplay-process.js

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+/** Short, bounded probes. Only stdout is returned; protocol diagnostics stay private. */
+export const runAirPlayCommand = (command, args, timeoutMs, maxOutputBytes, options) => new Promise(resolve => {
+    const chunks = [];
+    let bytes = 0;
+    let totalBytes = 0;
+    let settled = false;
+    let child;
+    const finish = (code, timedOut = false, truncated = false) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ output: Buffer.concat(chunks, bytes).toString('utf8'), code, timedOut, truncated });
+    };
+    const stop = () => {
+        if (settled || !child)
+            return;
+        // A dedicated POSIX process group includes ordinary helper descendants.
+        // Closing inherited pipes and releasing the child handle also bounds the
+        // parent on Windows, or if a descendant escaped into a separate session.
+        if (process.platform !== 'win32' && child.pid) {
+            try {
+                process.kill(-child.pid, 'SIGKILL');
+            }
+            catch { /* The group may already have exited. */ }
+        }
+        try {
+            child.kill('SIGKILL');
+        }
+        catch { /* Still release our handles if termination fails. */ }
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        child.unref();
+    };
+    const timer = setTimeout(() => { stop(); finish(null, true); }, Math.max(1, timeoutMs));
+    try {
+        child = spawn(command, args, { detached: process.platform !== 'win32', windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], env: { ...(options?.env ?? process.env), LC_ALL: 'C' } });
+    }
+    catch {
+        finish(null);
+        return;
+    }
+    const append = (chunk, stdout) => {
+        if (settled)
+            return;
+        const remaining = Math.max(0, maxOutputBytes - totalBytes);
+        totalBytes += chunk.length;
+        if (stdout && remaining > 0) {
+            const kept = chunk.subarray(0, remaining);
+            chunks.push(kept);
+            bytes += kept.length;
+        }
+        if (totalBytes > maxOutputBytes) {
+            stop();
+            finish(null, false, true);
+        }
+    };
+    child.stdout?.on('data', (chunk) => append(chunk, true));
+    child.stderr?.on('data', (chunk) => append(chunk, false));
+    child.once('error', () => { stop(); finish(null); });
+    child.once('close', code => finish(code));
+});