@ciphore/radiocli 0.1.2 → 0.1.4

package/dist/player/airplay-worker-protocol.js

@@ -0,0 +1,144 @@
+const maxWorkerStartBytes = 16_384;
+export const maxWorkerMessageBytes = 8192;
+const maxWorkerTextBytes = 512;
+const maxPasscodeBytes = 64;
+export function encodeWorkerStart(start) {
+    return Buffer.from(JSON.stringify(start), 'utf8').toString('base64url');
+}
+export function decodeWorkerStart(encoded) {
+    const decoded = Buffer.from(encoded, 'base64url').toString('utf8');
+    if (Buffer.byteLength(decoded, 'utf8') > maxWorkerStartBytes) {
+        throw new Error('AirPlay worker start payload is too large.');
+    }
+    return validateWorkerStart(JSON.parse(decoded));
+}
+export function serializeWorkerMessage(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+export function parseWorkerMessage(line) {
+    if (!line.trim()) {
+        return null;
+    }
+    if (Buffer.byteLength(line, 'utf8') > maxWorkerMessageBytes) {
+        return null;
+    }
+    try {
+        return validateWorkerMessage(JSON.parse(line));
+    }
+    catch {
+        return null;
+    }
+}
+function validateWorkerStart(value) {
+    if (!isRecord(value) || !isRecord(value.device)) {
+        throw new Error('Invalid AirPlay worker start payload.');
+    }
+    const device = value.device;
+    const port = Number(device.port);
+    const txt = Array.isArray(device.txt)
+        ? device.txt.slice(0, 64).map(item => boundedString(item, 'txt', 512)).filter(Boolean)
+        : [];
+    return {
+        streamUrl: boundedHttpUrl(value.streamUrl, 'streamUrl'),
+        stationName: boundedText(value.stationName, 'stationName', maxWorkerTextBytes),
+        volume: clampVolume(Number(value.volume)),
+        muted: typeof value.muted === 'boolean' ? value.muted : false,
+        device: {
+            id: boundedText(device.id, 'device.id', 256),
+            name: boundedText(device.name, 'device.name', 256),
+            host: safeHost(device.host),
+            port: Number.isInteger(port) && port > 0 && port <= 65535 ? port : invalid('device.port'),
+            txt,
+            requiresPassword: Boolean(device.requiresPassword),
+            airplay2: Boolean(device.airplay2)
+        }
+    };
+}
+function validateWorkerMessage(value) {
+    if (!isRecord(value) || typeof value.type !== 'string') {
+        return null;
+    }
+    if (value.type === 'stop') {
+        return { type: 'stop' };
+    }
+    if (value.type === 'setVolume') {
+        return Number.isFinite(Number(value.volume)) ? { type: 'setVolume', volume: clampVolume(Number(value.volume)) } : null;
+    }
+    if (value.type === 'setMuted') {
+        return typeof value.muted === 'boolean' ? { type: 'setMuted', muted: value.muted } : null;
+    }
+    if (value.type === 'retune') {
+        try {
+            return {
+                type: 'retune',
+                streamUrl: boundedHttpUrl(value.streamUrl, 'streamUrl'),
+                stationName: boundedText(value.stationName, 'stationName', maxWorkerTextBytes)
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    if (value.type === 'passcode') {
+        if (typeof value.code !== 'string' || Buffer.byteLength(value.code, 'utf8') > maxPasscodeBytes) {
+            return null;
+        }
+        const code = cleanText(value.code, maxPasscodeBytes);
+        return code ? { type: 'passcode', code } : null;
+    }
+    if (value.type === 'ready' || value.type === 'playing' || value.type === 'retuned' || value.type === 'password-required' || value.type === 'stopped') {
+        return { type: value.type };
+    }
+    if (value.type === 'buffer') {
+        return { type: 'buffer', status: cleanText(value.status, 120) || 'unknown' };
+    }
+    if (value.type === 'error') {
+        return { type: 'error', message: cleanText(value.message, maxWorkerTextBytes) || 'AirPlay worker error.' };
+    }
+    return null;
+}
+function boundedString(value, field, maxBytes) {
+    if (typeof value !== 'string' || !value.trim()) {
+        return invalid(field);
+    }
+    const cleaned = cleanText(value, maxBytes);
+    return cleaned || invalid(field);
+}
+function boundedText(value, field, maxBytes) {
+    return boundedString(value, field, maxBytes);
+}
+function boundedHttpUrl(value, field) {
+    const streamUrl = boundedString(value, field, 4096);
+    const parsedUrl = new URL(streamUrl);
+    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+        throw new Error('AirPlay streams must use http or https URLs.');
+    }
+    return streamUrl;
+}
+function cleanText(value, maxBytes) {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    const withoutControls = value.replace(/[\u0000-\u001F\u007F-\u009F]/g, ' ').replace(/\s+/g, ' ').trim();
+    let cleaned = withoutControls;
+    while (Buffer.byteLength(cleaned, 'utf8') > maxBytes) {
+        cleaned = cleaned.slice(0, -1);
+    }
+    return cleaned.trim();
+}
+function safeHost(value) {
+    const host = boundedString(value, 'device.host', 253).replace(/\.$/, '');
+    if (/[\s/\\]/.test(host) || !/^[A-Za-z0-9._:%-]+$/.test(host)) {
+        return invalid('device.host');
+    }
+    return host;
+}
+function clampVolume(volume) {
+    return Math.min(100, Math.max(0, Math.round(Number.isFinite(volume) ? volume : 70)));
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function invalid(field) {
+    throw new Error(`Invalid AirPlay worker ${field}.`);
+}

package/dist/player/airplay-worker.js

@@ -0,0 +1,218 @@
+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 { 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`);
+};
+const encodedStart = process.argv[2];
+if (!encodedStart) {
+    emit({ type: 'error', message: 'Missing AirPlay worker start payload.' });
+    process.exit(1);
+}
+const AirTunes = loadAirTunesSender();
+const start = decodeStartPayload(encodedStart);
+const airtunes = new AirTunes();
+let deviceKey = '';
+let ffmpeg = null;
+let muted = start.muted;
+let volume = start.volume;
+let retuning = false;
+let stopping = false;
+airtunes.on('device', (key, status) => {
+    if (typeof key === 'string') {
+        deviceKey = key;
+    }
+    if (status === 'ready') {
+        emit({ type: 'ready' });
+    }
+    else if (status === 'playing' || status === 'pair_success') {
+        emit({ type: 'playing' });
+    }
+    else if (status === 'need_password') {
+        emit({ type: 'password-required' });
+    }
+    else if (status === 'stopped') {
+        emit({ type: 'stopped' });
+    }
+    else if (status === 'error') {
+        emit({ type: 'error', message: 'AirPlay receiver reported an error.' });
+    }
+});
+airtunes.on('buffer', status => {
+    const statusText = String(status);
+    emit({ type: 'buffer', status: statusText });
+    if (retuning && statusText === 'playing') {
+        retuning = false;
+        emit({ type: 'retuned' });
+    }
+});
+airtunes.on('error', error => {
+    emit({ type: 'error', message: error instanceof Error ? error.message : String(error) });
+});
+const device = airtunes.add(start.device.host, {
+    port: start.device.port,
+    volume: muted ? 0 : volume,
+    txt: start.device.txt,
+    airplay2: start.device.airplay2,
+    forceAlac: true,
+    debug: false,
+    mode: start.device.airplay2 ? 2 : 0
+});
+deviceKey = device.key;
+startFfmpeg(start.streamUrl);
+let stdinBuffer = '';
+process.stdin.on('data', chunk => {
+    stdinBuffer += chunk.toString('utf8');
+    if (Buffer.byteLength(stdinBuffer, 'utf8') > maxWorkerMessageBytes) {
+        emit({ type: 'error', message: 'AirPlay worker command exceeded the size limit.' });
+        stdinBuffer = '';
+        return;
+    }
+    let newlineIndex = stdinBuffer.indexOf('\n');
+    while (newlineIndex !== -1) {
+        const line = stdinBuffer.slice(0, newlineIndex);
+        stdinBuffer = stdinBuffer.slice(newlineIndex + 1);
+        newlineIndex = stdinBuffer.indexOf('\n');
+        const command = parseWorkerMessage(line);
+        if (command) {
+            handleCommand(command);
+        }
+    }
+});
+process.once('SIGTERM', () => stop(0));
+process.once('SIGINT', () => stop(0));
+function handleCommand(command) {
+    if (command.type === 'stop') {
+        stop(0);
+    }
+    else if (command.type === 'setVolume') {
+        volume = clampVolume(command.volume);
+        setAirPlayVolume(muted ? 0 : volume);
+    }
+    else if (command.type === 'setMuted') {
+        muted = command.muted;
+        setAirPlayVolume(muted ? 0 : volume);
+    }
+    else if (command.type === 'retune') {
+        retuning = true;
+        airtunes.reset();
+        startFfmpeg(command.streamUrl);
+    }
+    else if (command.type === 'passcode') {
+        device.setPasscode?.(command.code);
+    }
+}
+function startFfmpeg(streamUrl) {
+    const previous = ffmpeg;
+    const child = spawn('ffmpeg', [
+        '-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',
+        '-i',
+        streamUrl,
+        '-f',
+        's16le',
+        '-ac',
+        '2',
+        '-ar',
+        '44100',
+        'pipe:1'
+    ], {
+        stdio: ['ignore', 'pipe', 'pipe']
+    });
+    ffmpeg = child;
+    if (previous && !previous.killed) {
+        previous.kill('SIGTERM');
+    }
+    child.stdout.on('data', chunk => {
+        if (ffmpeg === child && !stopping) {
+            airtunes.write(chunk);
+        }
+    });
+    child.stderr.on('data', chunk => {
+        if (ffmpeg === child) {
+            process.stderr.write(chunk);
+        }
+    });
+    child.once('error', error => {
+        if (ffmpeg !== child || stopping) {
+            return;
+        }
+        emit({ type: 'error', message: error.message });
+        stop(1);
+    });
+    child.once('exit', code => {
+        if (ffmpeg !== child || stopping) {
+            return;
+        }
+        ffmpeg = null;
+        if (code !== 0) {
+            emit({ type: 'error', message: `ffmpeg exited with code ${code}` });
+        }
+        stop(code ?? 0);
+    });
+}
+function setAirPlayVolume(nextVolume) {
+    if (deviceKey) {
+        airtunes.setVolume(deviceKey, nextVolume);
+    }
+}
+function emit(event) {
+    process.stdout.write(serializeWorkerMessage(event));
+}
+function loadAirTunesSender() {
+    const health = airPlaySenderHealth();
+    if (!health.safe) {
+        emit({ type: 'error', message: health.message });
+        process.exit(1);
+    }
+    installAirPlaySenderPatch();
+    try {
+        return require('node-airtunes2');
+    }
+    catch {
+        emit({ type: 'error', message: 'AirPlay sender bridge could not be loaded.' });
+        process.exit(1);
+    }
+}
+function decodeStartPayload(encoded) {
+    try {
+        return decodeWorkerStart(encoded);
+    }
+    catch (error) {
+        emit({ type: 'error', message: error instanceof Error ? error.message : 'Invalid AirPlay worker start payload.' });
+        process.exit(1);
+    }
+}
+function stop(code) {
+    if (stopping) {
+        return;
+    }
+    stopping = true;
+    if (ffmpeg && !ffmpeg.killed) {
+        ffmpeg.kill('SIGTERM');
+    }
+    ffmpeg = null;
+    airtunes.stopAll(() => {
+        emit({ type: 'stopped' });
+        process.exit(code);
+    });
+}
+function clampVolume(nextVolume) {
+    return Math.min(100, Math.max(0, Math.round(nextVolume)));
+}

package/dist/player/backend-install.js

@@ -1,8 +1,59 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { commandExists } from './command.js';
-const playbackBackends = ['mpv', 'ffplay'];
-export function detectPlaybackBackends() {
-    return playbackBackends.filter(commandExists);
+import { airPlaySenderHealth } from './airplay-sender-health.js';
+export const ffplayLimitedControlsMessage = 'ffplay fallback has limited controls. Install mpv for pause, mute, volume, and media keys.';
+export function detectPlaybackBackends({ platform = process.platform, hasCommand = commandExists, hasAirPlaySender = hasAirPlaySenderPackage } = {}) {
+    const backends = ['mpv', 'ffplay'].filter(hasCommand);
+    if (platform === 'darwin' && hasCommand('ffmpeg') && hasCommand('dns-sd') && hasAirPlaySender()) {
+        backends.push('airplay');
+    }
+    return backends;
+}
+function hasAirPlaySenderPackage() {
+    return airPlaySenderHealth().safe;
+}
+export function playbackBackendCapabilities(backend) {
+    if (backend === 'mpv') {
+        return {
+            backend,
+            label: 'mpv',
+            supportsPause: true,
+            supportsMute: true,
+            supportsVolume: true,
+            supportsMediaKeys: true
+        };
+    }
+    if (backend === 'ffplay') {
+        return {
+            backend,
+            label: 'ffplay fallback',
+            supportsPause: false,
+            supportsMute: false,
+            supportsVolume: false,
+            supportsMediaKeys: false
+        };
+    }
+    if (backend === 'airplay') {
+        return {
+            backend,
+            label: 'AirPlay',
+            supportsPause: false,
+            supportsMute: true,
+            supportsVolume: true,
+            supportsMediaKeys: false
+        };
+    }
+    return {
+        backend: backend ?? 'none',
+        label: backend || 'no backend',
+        supportsPause: false,
+        supportsMute: false,
+        supportsVolume: false,
+        supportsMediaKeys: false
+    };
+}
+export function playbackBackendLabel(backend) {
+    return playbackBackendCapabilities(backend).label;
 }
 export function playbackBackendInstallHint(platform = process.platform, osRelease = readLinuxOsRelease()) {
     return `Install mpv for playback (${mpvInstallCommand(platform, osRelease)}), then run radiocli doctor.`;
@@ -10,7 +61,7 @@ export function playbackBackendInstallHint(platform = process.platform, osReleas
 export function playbackBackendStatusLines(backends, platform = process.platform, osRelease = readLinuxOsRelease()) {
     const backendSet = new Set(backends);
     const lines = [
-        'npm_install=RadioCLI only; native playback comes from mpv or ffplay',
+        'npm_install=RadioCLI includes the AirPlay sender; native playback tools come from mpv and FFmpeg',
         `install_mpv=${mpvInstallCommand(platform, osRelease)}`,
         `optional_ffplay=${ffplayInstallCommand(platform, osRelease)}`
     ];
@@ -18,6 +69,7 @@ export function playbackBackendStatusLines(backends, platform = process.platform
         return [
             'playback=ready',
             'playback_backend=mpv',
+            'controls=full',
             ...lines
         ];
     }
@@ -25,12 +77,25 @@ export function playbackBackendStatusLines(backends, platform = process.platform
         return [
             'playback=fallback-only',
             'playback_backend=ffplay',
+            'controls=limited',
+            'controls_hint=install mpv for pause, mute, volume, and media keys',
+            ...lines
+        ];
+    }
+    if (backendSet.has('airplay')) {
+        return [
+            'playback=airplay-only',
+            'playback_backend=airplay',
+            'controls=airplay-limited',
+            'controls_hint=AirPlay supports volume and mute; pause is not supported',
             ...lines
         ];
     }
     return [
         'playback=missing',
         'playback_backend=none',
+        'controls=missing',
+        'controls_hint=install mpv for playback and controls',
         ...lines
     ];
 }