@ciphore/radiocli 0.2.3 → 0.2.5

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);

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

@@ -1,5 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
+import { airPlaySenderRoot } from './airplay-sender-package.js';
 const require = createRequire(import.meta.url);
 const setupAp2DigestGuard = 'this.status === SETUP_AP2_1 && response.code === 401';
 const responseHeadersMarker = '    headers = response.headers';
@@ -58,6 +59,10 @@ const bufferedSocketDataHandler = `  var blob = Buffer.alloc(0)
     self.clearTimeout()
 
     blob = Buffer.concat([blob, Buffer.from(data)])
+    if (blob.length > 1024 * 1024) {
+      self.cleanup('invalid_response')
+      return
+    }
     while (blob.length > 0) {
       var endIndex = blob.indexOf('\\r\\n\\r\\n')
 
@@ -69,6 +74,10 @@ const bufferedSocketDataHandler = `  var blob = Buffer.alloc(0)
       var headers = blob.slice(0, endIndex).toString()
       var lengthMatch = /(?:^|\\r\\n)Content-Length:\\s*(\\d+)/i.exec(headers)
       var contentLength = lengthMatch ? parseInt(lengthMatch[1], 10) : 0
+      if (!Number.isSafeInteger(contentLength) || contentLength > 1024 * 1024) {
+        self.cleanup('invalid_response')
+        return
+      }
       var messageLength = endIndex + contentLength
 
       if (blob.length < messageLength) {
@@ -82,13 +91,15 @@ const bufferedSocketDataHandler = `  var blob = Buffer.alloc(0)
     }
   })`;
 let installed = false;
-export function installAirPlaySenderPatch(packageName = 'node-airtunes2') {
+export function installAirPlaySenderPatch(packageName = airPlaySenderRoot) {
     if (installed) {
         return true;
     }
     let rtspPath;
+    let devicePath;
     try {
         rtspPath = require.resolve(`${packageName}/lib/rtsp.js`);
+        devicePath = require.resolve(`${packageName}/lib/device_airtunes.js`);
     }
     catch {
         return false;
@@ -99,17 +110,18 @@ export function installAirPlaySenderPatch(packageName = 'node-airtunes2') {
         return false;
     }
     moduleLoader._extensions['.js'] = (module, filename) => {
-        if (filename !== rtspPath) {
+        if (filename !== rtspPath && filename !== devicePath) {
             originalLoader(module, filename);
             return;
         }
-        module._compile(patchAirTunesRtspSource(readFileSync(filename, 'utf8')), filename);
+        const source = readFileSync(filename, 'utf8');
+        module._compile(filename === rtspPath ? patchAirTunesRtspSource(source) : patchAirTunesDeviceSource(source), filename);
     };
     installed = true;
     return true;
 }
 export function patchAirTunesRtspSource(source) {
-    let patched = source;
+    let patched = patchQueuedControls(patchLegacyDigest(source));
     if (patched.includes(socketDataHandlerMarker) && !patched.includes('Buffer.concat([blob, Buffer.from(data)])')) {
         patched = patched.replace(socketDataHandlerMarker, bufferedSocketDataHandler);
     }
@@ -136,3 +148,89 @@ export function patchAirTunesRtspSource(source) {
 `;
     return patched.replace(processDataResponseMarker, `${setupAp2DigestRetry}${processDataResponseMarker}`);
 }
+/** A zero starting volume is intentional, including when a session starts muted. */
+export function patchAirTunesDeviceSource(source) {
+    return source.replaceAll('options.volume || 50', 'options.volume ?? 50').replaceAll('this.options.volume || 30', 'this.options.volume ?? 30');
+}
+function patchLegacyDigest(source) {
+    if (source.includes('// RadioCLI legacy Digest'))
+        return source;
+    return source.replace('  this.status = this.airplay2 ? PAIR_SETUP_1 : PAIR_PIN_SETUP_1\n  this.sendNextRequest()', `  if (!this.airplay2 && this.mode === 0 && (this.radioCliDigest || this.status === OPTIONS)) {
+    if (this.radioCliDigest) {
+      this.radioCliDigest.password = passcode
+      this.radioCliDigestTried = true
+      this.sendNextRequest(this.radioCliDigest)
+    }
+    return
+  }
+  this.status = this.airplay2 ? PAIR_SETUP_1 : PAIR_PIN_SETUP_1
+  this.sendNextRequest()`)
+        .replace("  var head = method + ' ' + uri + ' RTSP/1.0'", "  if (!this.airplay2 && this.mode === 0) di = di || this.radioCliDigest\n  var head = method + ' ' + uri + ' RTSP/1.0'")
+        .replace("    if (dimode == 'airplay2') {", "    if (dimode == 'airplay2' || (!this.airplay2 && this.mode === 0)) {")
+        .replace("      diResponse = md5(ha1 + ':' + di.nonce + ':' + ha2)", "      diResponse = (!this.airplay2 && this.mode === 0 ? md5norm : md5)(ha1 + ':' + di.nonce + ':' + ha2)")
+        .replace(processDataResponseMarker, `  // RadioCLI legacy Digest: keep password authentication separate from PIN pairing.
+  if (!this.airplay2 && this.mode === 0 && response.code === 401 &&
+      (this.status === OPTIONS || /^Digest\\s/i.test(headers['WWW-Authenticate'] || headers['www-authenticate'] || ''))) {
+    const auth = headers['WWW-Authenticate'] || headers['www-authenticate']
+    if (this.radioCliDigestTried || typeof auth !== 'string' || !/^Digest\\s/i.test(auth)) {
+      this.emit('pair_failed')
+      this.cleanup('bad_password')
+      return
+    }
+    const realm = parseAuthenticate(auth, 'realm')
+    const nonce = parseAuthenticate(auth, 'nonce')
+    if (!realm || !nonce || /[\\r\\n"]/.test(realm + nonce)) {
+      this.emit('pair_failed')
+      this.cleanup('bad_password')
+      return
+    }
+    this.radioCliDigest = {realm, nonce, username: 'iTunes', password: this.password}
+    if (!this.password) {
+      this.emit('need_password')
+      return
+    }
+    this.radioCliDigestTried = true
+    this.sendNextRequest(this.radioCliDigest)
+    return
+  }
+  if (response.code === 200) this.radioCliDigestTried = false
+${processDataResponseMarker}`);
+}
+/** The upstream sender silently drops controls while another RTSP request is in flight. */
+function patchQueuedControls(source) {
+    if (source.includes('this.radioCliPendingVolume'))
+        return source;
+    return source.replace(`Client.prototype.setVolume = function (volume, callback) {
+  if (this.status !== PLAYING)
+    return`, `Client.prototype.setVolume = function (volume, callback) {
+  if (this.status !== PLAYING) {
+    if (this.status !== CLOSED && this.status !== TEARDOWN) this.radioCliPendingVolume = [volume, callback]
+    return
+  }`)
+        .replace(`Client.prototype.setTrackInfo = function (name, artist, album, callback) {
+  if (this.status !== PLAYING)
+    return`, `Client.prototype.setTrackInfo = function (name, artist, album, callback) {
+  if (this.status !== PLAYING) {
+    if (this.status !== CLOSED && this.status !== TEARDOWN) this.radioCliPendingTrack = [name, artist, album, callback]
+    return
+  }`)
+        .replace(`  this.sendNextRequest()
+}
+
+Client.prototype.parseObject`, `  if (this.status === PLAYING && this.radioCliPendingVolume) {
+    const pending = this.radioCliPendingVolume
+    this.radioCliPendingVolume = null
+    this.setVolume(...pending)
+    return
+  }
+  if (this.status === PLAYING && this.radioCliPendingTrack) {
+    const pending = this.radioCliPendingTrack
+    this.radioCliPendingTrack = null
+    this.setTrackInfo(...pending)
+    return
+  }
+  this.sendNextRequest()
+}
+
+Client.prototype.parseObject`);
+}

package/dist/player/airplay-setup.js

@@ -0,0 +1,51 @@
+import { statSync } from 'node:fs';
+import { packageInstallCommand } from '../platform/packages.js';
+const airPlaySenderInstallGuidance = 'Reinstall RadioCLI with optional dependencies enabled (npm install -g @ciphore/radiocli --include=optional), then rerun radiocli doctor. Use the same installation method and prefix as the current install.';
+export function hasSystemdSystemManager() {
+    try {
+        return process.platform === 'linux' && statSync('/run/systemd/system').isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Only apt and Arch have verified Avahi package recipes here. */
+export function linuxAirPlaySetupPlan({ manager, elevation, hasCommand, systemd, serviceReady, existingCommands }) {
+    const commands = [];
+    const notes = ['Experimental Linux AirPlay is optional. Avahi supplies shared local-network discovery; enabling its system service affects the whole machine.'];
+    if (!hasCommand('ffmpeg') && !existingCommands.some(command => command.component === 'ffmpeg')) {
+        const command = manager ? packageInstallCommand(manager, 'ffmpeg', { elevation }) : null;
+        if (command)
+            commands.push({ ...command, component: null, label: 'AirPlay FFmpeg' });
+        else
+            notes.push('Install FFmpeg manually for AirPlay, then rerun radiocli setup --airplay.');
+    }
+    if (!hasCommand('avahi-browse') || !serviceReady && !hasCommand('avahi-daemon')) {
+        const recipe = manager === 'apt' ? ['apt-get', 'install', '-y', 'avahi-daemon', 'avahi-utils']
+            : manager === 'pacman' ? ['pacman', '-S', '--needed', '--noconfirm', 'avahi'] : null;
+        if (recipe)
+            commands.push(setupAction('Avahi discovery', recipe, elevation));
+        else
+            notes.push('Install Avahi daemon and avahi-browse with your distribution package manager; no verified automatic Avahi recipe is available for this manager.');
+    }
+    if (!serviceReady) {
+        if (systemd && hasCommand('systemctl') && (hasCommand('avahi-daemon') || manager === 'apt' || manager === 'pacman')) {
+            commands.push(setupAction('Enable and start shared Avahi service', ['systemctl', 'enable', '--now', 'avahi-daemon.service'], elevation));
+        }
+        else
+            notes.push('Start the Avahi daemon with your system service manager, then rerun radiocli doctor. RadioCLI will not guess or change this service configuration.');
+    }
+    return { commands, notes };
+}
+export function airPlaySetupVerification(readiness) {
+    const ready = readiness.ready && readiness.discoveryService === 'ready';
+    return [
+        ready ? 'AirPlay: experimental prerequisites ready. Select a receiver to verify playback.' : `AirPlay: Setup required. ${readiness.message}`,
+        ...(!readiness.senderLoaded ? [airPlaySenderInstallGuidance] : []),
+        ...(readiness.discoveryService === 'unverified' ? ['Avahi service readiness is unverified. Install busctl or verify the running daemon with your system administrator; receiver discovery remains available explicitly.'] : [])
+    ];
+}
+function setupAction(label, invocation, elevation) {
+    const [program, ...args] = elevation ? [elevation, ...invocation] : invocation;
+    return { component: null, label, program: program, args, display: [program, ...args].join(' ') };
+}

package/dist/player/airplay-worker.js

@@ -2,12 +2,13 @@ import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { airPlaySenderHealth } from './airplay-sender-health.js';
 import { installAirPlaySenderPatch } from './airplay-sender-patch.js';
+import { airPlaySenderRoot } from './airplay-sender-package.js';
+import { canRetryPlainHttp, ffmpegCertificateFailure, ffmpegInputArguments, ffmpegInputFailure } from './ffmpeg-input.js';
 import { parseWorkerMessage, decodeWorkerStart, maxWorkerMessageBytes, serializeWorkerMessage } from './airplay-worker-protocol.js';
 const require = createRequire(import.meta.url);
-// node-airtunes2 writes diagnostics with console.log; keep stdout reserved for JSON events.
-console.log = (...args) => {
-    process.stderr.write(`${args.map(String).join(' ')}\n`);
-};
+// The optional sender logs raw authentication exchanges, including receiver codes.
+// Only our bounded protocol events may leave this isolated process.
+console.log = console.info = console.debug = console.warn = console.error = () => undefined;
 const encodedStart = process.argv[2];
 if (!encodedStart) {
     emit({ type: 'error', message: 'Missing AirPlay worker start payload.' });
@@ -18,15 +19,21 @@ const start = decodeStartPayload(encodedStart);
 const airtunes = new AirTunes();
 let deviceKey = '';
 let ffmpeg = null;
+const decoders = new Set();
 let muted = start.muted;
 let volume = start.volume;
+let stationName = start.stationName;
 let retuning = false;
 let stopping = false;
+let finishStop;
 airtunes.on('device', (key, status) => {
+    if (stopping)
+        return;
     if (typeof key === 'string') {
         deviceKey = key;
     }
     if (status === 'ready') {
+        publishStation();
         emit({ type: 'ready' });
     }
     else if (status === 'playing' || status === 'pair_success') {
@@ -36,13 +43,18 @@ airtunes.on('device', (key, status) => {
         emit({ type: 'password-required' });
     }
     else if (status === 'stopped') {
-        emit({ type: 'stopped' });
+        fail('AirPlay receiver disconnected. Select the receiver again to reconnect.');
+    }
+    else if (status === 'pair_failed') {
+        fail('AirPlay receiver rejected the code or pairing request.');
     }
     else if (status === 'error') {
-        emit({ type: 'error', message: 'AirPlay receiver reported an error.' });
+        fail('AirPlay receiver reported an error.');
     }
 });
 airtunes.on('buffer', status => {
+    if (stopping)
+        return;
     const statusText = String(status);
     emit({ type: 'buffer', status: statusText });
     if (retuning && statusText === 'playing') {
@@ -50,9 +62,9 @@ airtunes.on('buffer', status => {
         emit({ type: 'retuned' });
     }
 });
-airtunes.on('error', error => {
-    emit({ type: 'error', message: error instanceof Error ? error.message : String(error) });
-});
+airtunes.on('error', () => fail('AirPlay sender failed. Select the receiver again to reconnect.'));
+airtunes.on('drain', () => { if (!stopping)
+    ffmpeg?.stdout.resume(); });
 const device = airtunes.add(start.device.host, {
     port: start.device.port,
     volume: muted ? 0 : volume,
@@ -85,7 +97,13 @@ process.stdin.on('data', chunk => {
 });
 process.once('SIGTERM', () => stop(0));
 process.once('SIGINT', () => stop(0));
+process.once('SIGHUP', () => stop(0));
+process.stdin.once('end', () => stop(0));
+process.once('uncaughtException', () => fail('AirPlay sender failed.'));
+process.once('unhandledRejection', () => fail('AirPlay sender failed.'));
 function handleCommand(command) {
+    if (stopping)
+        return;
     if (command.type === 'stop') {
         stop(0);
     }
@@ -99,30 +117,26 @@ function handleCommand(command) {
     }
     else if (command.type === 'retune') {
         retuning = true;
+        stationName = command.stationName;
         airtunes.reset();
         startFfmpeg(command.streamUrl);
+        publishStation();
     }
     else if (command.type === 'passcode') {
         device.setPasscode?.(command.code);
     }
 }
-function startFfmpeg(streamUrl) {
+function startFfmpeg(streamUrl, plainHttp = false) {
+    if (stopping)
+        return;
     const previous = ffmpeg;
     const child = spawn(start.ffmpegPath, [
         '-hide_banner',
         '-loglevel',
         'error',
-        // Recover from transient source drops without tearing down the AirPlay session.
-        // These are input options and must precede -i. -reconnect_streamed is essential for
-        // non-seekable radio; with no retry cap ffmpeg keeps trying until the station returns.
-        '-reconnect',
-        '1',
-        '-reconnect_on_network_error',
-        '1',
-        '-reconnect_streamed',
-        '1',
-        '-reconnect_delay_max',
-        '2',
+        // Reconnect only network inputs, retaining the receiver session across
+        // transient source drops without breaking local file playback.
+        ...ffmpegInputArguments(streamUrl, { plainHttp, reconnect: true }),
         '-i',
         streamUrl,
         '-f',
@@ -136,33 +150,44 @@ function startFfmpeg(streamUrl) {
         stdio: ['ignore', 'pipe', 'pipe']
     });
     ffmpeg = child;
-    if (previous && !previous.killed) {
-        previous.kill('SIGTERM');
-    }
+    decoders.add(child);
+    child.once('close', () => { decoders.delete(child); finishStop?.(); });
+    if (previous)
+        stopDecoder(previous);
+    let pcmStarted = false;
+    let diagnostic = '';
     child.stdout.on('data', chunk => {
         if (ffmpeg === child && !stopping) {
-            airtunes.write(chunk);
+            pcmStarted ||= chunk.length > 0;
+            if (!airtunes.write(chunk))
+                child.stdout.pause();
         }
     });
+    // Inspect only a bounded tail; never forward stream URLs or credentials.
     child.stderr.on('data', chunk => {
-        if (ffmpeg === child) {
-            process.stderr.write(chunk);
-        }
+        diagnostic = (diagnostic + String(chunk)).slice(-8192);
+        const failure = ffmpegInputFailure(diagnostic) ?? ffmpegCertificateFailure(diagnostic);
+        if (failure && ffmpeg === child && !stopping)
+            fail(failure);
     });
-    child.once('error', error => {
+    child.stderr.resume();
+    child.once('error', () => {
         if (ffmpeg !== child || stopping) {
             return;
         }
-        emit({ type: 'error', message: error.message });
-        stop(1);
+        fail('FFmpeg could not start for AirPlay playback. Run radiocli doctor.');
     });
-    child.once('exit', code => {
+    child.once('close', (code, signal) => {
         if (ffmpeg !== child || stopping) {
             return;
         }
+        if (!plainHttp && !signal && !pcmStarted && canRetryPlainHttp(streamUrl, diagnostic)) {
+            startFfmpeg(streamUrl, true);
+            return;
+        }
         ffmpeg = null;
         if (code !== 0) {
-            emit({ type: 'error', message: `ffmpeg exited with code ${code}` });
+            emit({ type: 'error', message: ffmpegInputFailure(diagnostic) ?? `ffmpeg exited with code ${code}` });
         }
         stop(code ?? 0);
     });
@@ -172,6 +197,24 @@ function setAirPlayVolume(nextVolume) {
         airtunes.setVolume(deviceKey, nextVolume);
     }
 }
+function publishStation() {
+    if (deviceKey)
+        airtunes.setTrackInfo(deviceKey, stationName, 'RadioCLI', 'Live radio');
+}
+function fail(message) {
+    if (stopping)
+        return;
+    emit({ type: 'error', message });
+    stop(1);
+}
+function stopDecoder(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    child.kill('SIGTERM');
+    const force = setTimeout(() => child.kill('SIGKILL'), 500);
+    force.unref();
+    child.once('close', () => clearTimeout(force));
+}
 function emit(event) {
     process.stdout.write(serializeWorkerMessage(event));
 }
@@ -183,7 +226,7 @@ function loadAirTunesSender() {
     }
     installAirPlaySenderPatch();
     try {
-        return require('node-airtunes2');
+        return require(airPlaySenderRoot);
     }
     catch {
         emit({ type: 'error', message: 'AirPlay sender bridge could not be loaded.' });
@@ -204,17 +247,30 @@ function stop(code) {
         return;
     }
     stopping = true;
-    if (ffmpeg && !ffmpeg.killed) {
-        ffmpeg.kill('SIGTERM');
-    }
+    process.exitCode = code;
+    for (const child of decoders)
+        stopDecoder(child);
     ffmpeg = null;
-    const watchdog = setTimeout(() => process.exit(code), 1500);
-    watchdog.unref();
-    airtunes.stopAll(() => {
+    let senderStopped = false;
+    const watchdog = setTimeout(() => {
+        for (const child of decoders)
+            child.kill('SIGKILL');
+        process.exit(code);
+    }, 1500);
+    finishStop = () => {
+        if (!senderStopped || decoders.size)
+            return;
         clearTimeout(watchdog);
         emit({ type: 'stopped' });
         process.exit(code);
-    });
+    };
+    try {
+        airtunes.stopAll(() => { senderStopped = true; finishStop?.(); });
+    }
+    catch {
+        senderStopped = true;
+        finishStop();
+    }
 }
 function clampVolume(nextVolume) {
     return Math.min(100, Math.max(0, Math.round(nextVolume)));