@ciphore/radiocli 0.2.4 → 0.2.5

package/dist/platform/terminals.js

@@ -4,6 +4,7 @@ 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'] },
@@ -14,7 +15,9 @@ const unixTerminals = [
     { 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 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`;
@@ -35,7 +38,12 @@ export function detectGraphicalTerminal(platform = process.platform, env = proce
     }
     if (adapter !== 'unix' || !hasDisplay(env))
         return unsupported;
-    if (configured) {
+    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') {
@@ -47,6 +55,8 @@ export function detectGraphicalTerminal(platform = process.platform, env = proce
     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)
@@ -58,7 +68,7 @@ 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 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.');
@@ -94,6 +104,14 @@ export function createTerminalLaunch(options) {
             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)
@@ -118,7 +136,9 @@ export async function launchTerminalCommand(options) {
     // 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 });
+    // 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; }

package/dist/player/airplay-discovery.js

@@ -1,28 +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 '../platform/executables.js';
+import { resolveCommandDetails } from '../platform/executables.js';
 import { networkPolicy } from '../platform/network.js';
-import { identifyPlatform, nativeAdapters } from '../platform/runtime.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 (networkPolicy().offline || !nativeAdapters(identifyPlatform({ platform })).airPlay || !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;
     }
@@ -62,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]) {
@@ -76,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)))
     };
 }
@@ -109,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(/\.$/, '');
@@ -126,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));
+});

package/dist/player/airplay-readiness.js

@@ -0,0 +1,42 @@
+import { resolveCommandDetails } from '../platform/executables.js';
+import { sessionBusSocket } from '../platform/mpris.js';
+import { isAirPlayPlatformSupported } from './backend-install.js';
+import { runAirPlayCommand } from './airplay-process.js';
+import { probeAirPlaySender } from './airplay-sender-health.js';
+/** Does not browse the network, activate services, or open a receiver. */
+export async function probeAirPlayReadiness({ platform = process.platform, env = process.env, release, resolve = command => resolveCommandDetails(command, { platform, env }).path ?? undefined, hasCommand = command => Boolean(resolve(command)), run = runAirPlayCommand, sender = probeAirPlaySender } = {}) {
+    const eligible = isAirPlayPlatformSupported(platform, env, release);
+    const discoveryExecutable = eligible && hasCommand(platform === 'linux' ? 'avahi-browse' : 'dns-sd');
+    const ffmpeg = eligible && hasCommand('ffmpeg');
+    const busctl = eligible && platform === 'linux' && hasCommand('busctl') ? resolve('busctl') : undefined;
+    let discoveryService = 'unverified';
+    const senderResult = eligible ? sender() : Promise.resolve({ loaded: false, message: 'AirPlay is not supported in this environment.' });
+    if (!discoveryExecutable)
+        discoveryService = 'unavailable';
+    else if (platform === 'linux' && busctl) {
+        const socket = sessionBusSocket(env.DBUS_SYSTEM_BUS_ADDRESS ?? 'unix:path=/run/dbus/system_bus_socket');
+        if (!socket)
+            discoveryService = 'unavailable';
+        else {
+            // --system still honors executable/network transport overrides. Pass only
+            // one validated Unix address and remove all inherited D-Bus fallbacks.
+            const address = `unix:${socket.startsWith('\0') ? 'abstract' : 'path'}=${encodeURIComponent(socket.startsWith('\0') ? socket.slice(1) : socket)}`;
+            const childEnv = { ...env };
+            for (const key of Object.keys(childEnv))
+                if (key.startsWith('DBUS_'))
+                    delete childEnv[key];
+            const result = await run(busctl, [`--address=${address}`, '--auto-start=no', '--timeout=0.5', 'call', 'org.freedesktop.Avahi', '/', 'org.freedesktop.Avahi.Server', 'GetState'], 600, 4096, { env: childEnv });
+            discoveryService = result.code === 0 && /^i\s+2\s*$/.test(result.output.trim()) && !result.truncated && !result.timedOut ? 'ready' : 'unavailable';
+        }
+    }
+    const senderLoaded = (await senderResult).loaded;
+    const ready = eligible && discoveryExecutable && ffmpeg && senderLoaded && discoveryService !== 'unavailable';
+    const message = !eligible ? 'AirPlay is experimental on macOS and native Linux; this environment is not supported.'
+        : !discoveryExecutable ? `AirPlay discovery requires ${platform === 'linux' ? 'avahi-browse' : 'dns-sd'}.`
+            : discoveryService === 'unavailable' ? 'The Avahi discovery service is not ready. Local playback remains available.'
+                : !ffmpeg ? 'AirPlay playback requires FFmpeg.'
+                    : !senderLoaded ? 'The optional AirPlay sender could not load. Local playback remains available.'
+                        : discoveryService === 'unverified' ? 'AirPlay prerequisites are present; the discovery service and receiver connection must still be verified.'
+                            : 'Experimental AirPlay prerequisites are ready; select a receiver to verify playback.';
+    return { eligible, discoveryExecutable, discoveryService, senderLoaded, ffmpeg, ready, message };
+}

package/dist/player/airplay-sender-health.js

@@ -1,8 +1,38 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname } from 'node:path';
+import { runAirPlayCommand } from './airplay-process.js';
+import { airPlaySenderPackageJson } from './airplay-sender-package.js';
 const require = createRequire(import.meta.url);
 const airPlaySenderPackageName = 'node-airtunes2';
+let senderProbe;
+/** Explicit diagnostics/discovery only: loading native code stays outside the TUI. */
+export async function probeAirPlaySender(options = {}) {
+    const health = options.health ?? airPlaySenderHealth();
+    if (!health.safe)
+        return { loaded: false, message: health.message };
+    const key = `${process.execPath}:${health.packageName}:${health.version}`;
+    if (!options.run && senderProbe?.key === key && senderProbe.until > Date.now())
+        return senderProbe.result;
+    const result = (async () => {
+        const code = [
+            "const r = require('node:module').createRequire(process.argv[1]);",
+            "try { const s = r('./');",
+            "if (typeof s !== 'function' || typeof s.prototype.add !== 'function' || typeof s.prototype.stopAll !== 'function') process.exit(1);",
+            // The Linux binding is otherwise loaded only when constructing a receiver.
+            // Match the sender's JS fallback on a normal require failure, but contain
+            // native crashes here before advertising a loadable sender. No sockets.
+            "if (process.platform === 'linux') { try { r('./build/Release/airtunes'); } catch {} }",
+            'process.exit(0); } catch { process.exit(1); }'
+        ].join('\n');
+        const probe = await (options.run ?? runAirPlayCommand)(process.execPath, ['-e', code, airPlaySenderPackageJson], Math.min(1500, Math.max(1, options.timeoutMs ?? 1500)), 4096);
+        const loaded = probe.code === 0 && !probe.timedOut && !probe.truncated;
+        return { loaded, message: loaded ? 'The optional AirPlay sender loaded in an isolated process.' : 'The optional AirPlay sender could not load. Local playback remains available; run radiocli doctor.' };
+    })();
+    if (!options.run)
+        senderProbe = { key, until: Date.now() + 30_000, result };
+    return result;
+}
 export function airPlaySenderHealth(lookupPackage = lookupInstalledPackage) {
     const sender = lookupPackage(airPlaySenderPackageName);
     if (!sender) {
@@ -15,17 +45,21 @@ export function airPlaySenderHealth(lookupPackage = lookupInstalledPackage) {
             warningPackages: []
         };
     }
-    const vulnerablePackages = blockingAirPlaySenderPackages(sender, lookupPackage);
-    const warningPackages = warningAirPlaySenderPackages(sender, lookupPackage);
-    if (vulnerablePackages.length > 0) {
+    const missingPackages = (sender.dependencies ?? []).filter(name => !lookupPackage(name, [sender.root]));
+    if (missingPackages.length > 0) {
+        return { available: false, safe: false, packageName: sender.name, version: sender.version,
+            message: `Optional AirPlay sender dependencies are not installed: ${missingPackages.join(', ')}. Local playback remains available.`,
+            vulnerablePackages: [], warningPackages: [] };
+    }
+    if (!sender.nativeEd25519) {
         return {
             available: true,
             safe: false,
             packageName: sender.name,
             version: sender.version,
-            message: `Installed AirPlay sender ${sender.name}@${sender.version} is blocked because vulnerable transitive dependencies were found: ${vulnerablePackages.join(', ')}.`,
-            vulnerablePackages,
-            warningPackages
+            message: `AirPlay sender ${sender.name}@${sender.version} is missing the native Ed25519 security fix.`,
+            vulnerablePackages: [`${sender.name}@${sender.version}`],
+            warningPackages: []
         };
     }
     return {
@@ -33,34 +67,18 @@ export function airPlaySenderHealth(lookupPackage = lookupInstalledPackage) {
         safe: true,
         packageName: sender.name,
         version: sender.version,
-        message: warningPackages.length > 0
-            ? `Bundled AirPlay sender ${sender.name}@${sender.version} is available with warnings: ${warningPackages.join(', ')}.`
-            : `AirPlay sender ${sender.name}@${sender.version} passed the dependency safety gate.`,
+        message: `AirPlay sender ${sender.name}@${sender.version} uses native Ed25519 with its optional runtime dependencies installed.`,
         vulnerablePackages: [],
-        warningPackages
+        warningPackages: []
     };
 }
-function blockingAirPlaySenderPackages(sender, lookupPackage) {
-    const packagePaths = [sender.root];
-    const vulnerable = [];
-    const protobuf = lookupPackage('protobufjs', packagePaths);
-    if (protobuf && compareSemver(protobuf.version, '7.5.8') < 0) {
-        vulnerable.push(`protobufjs@${protobuf.version}`);
-    }
-    return vulnerable;
-}
-function warningAirPlaySenderPackages(sender, lookupPackage) {
-    const packagePaths = [sender.root];
-    const vulnerable = [];
-    const elliptic = lookupPackage('elliptic', packagePaths);
-    if (elliptic && compareSemver(elliptic.version, '6.6.2') < 0) {
-        vulnerable.push(`elliptic@${elliptic.version}`);
-    }
-    return vulnerable;
-}
 function lookupInstalledPackage(packageName, paths) {
     try {
-        const packageJsonPath = paths
+        // Package exports can hide package.json while exposing the runtime entry.
+        if (paths && packageName !== airPlaySenderPackageName) {
+            return { name: packageName, version: 'installed', root: dirname(require.resolve(packageName, { paths })) };
+        }
+        const packageJsonPath = packageName === airPlaySenderPackageName ? airPlaySenderPackageJson : paths
             ? require.resolve(`${packageName}/package.json`, { paths })
             : require.resolve(`${packageName}/package.json`);
         const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
@@ -70,29 +88,11 @@ function lookupInstalledPackage(packageName, paths) {
         return {
             name: parsed.name ?? packageName,
             version: parsed.version,
-            root: dirname(packageJsonPath)
+            root: dirname(packageJsonPath),
+            ...(packageName === airPlaySenderPackageName ? { nativeEd25519: parsed.radiocliLegacyPairing === 'node:crypto', dependencies: Object.keys(parsed.dependencies ?? {}) } : {})
         };
     }
     catch {
         return null;
     }
 }
-function compareSemver(left, right) {
-    const leftParts = semverParts(left);
-    const rightParts = semverParts(right);
-    for (let index = 0; index < 3; index += 1) {
-        const delta = leftParts[index] - rightParts[index];
-        if (delta !== 0) {
-            return delta;
-        }
-    }
-    return 0;
-}
-function semverParts(version) {
-    const [major = '0', minor = '0', patch = '0'] = version.split(/[.-]/);
-    return [
-        Number.parseInt(major, 10) || 0,
-        Number.parseInt(minor, 10) || 0,
-        Number.parseInt(patch, 10) || 0
-    ];
-}

package/dist/player/airplay-sender-package.js

@@ -0,0 +1,5 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// The same relative location works from src/player and the packaged dist/player.
+export const airPlaySenderPackageJson = fileURLToPath(new URL('../../vendor/node-airtunes2/package.json', import.meta.url));
+export const airPlaySenderRoot = dirname(airPlaySenderPackageJson);