@ciphore/radiocli 0.1.1 → 0.1.3

package/dist/player/airplay-worker.js

@@ -0,0 +1,178 @@
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { airPlaySenderHealth } from './airplay-sender-health.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 muted = start.muted;
+let volume = start.volume;
+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 => {
+    emit({ type: 'buffer', status: String(status) });
+    if (status === 'playing') {
+        emit({ type: 'playing' });
+    }
+});
+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;
+const ffmpeg = spawn('ffmpeg', [
+    '-hide_banner',
+    '-loglevel',
+    'error',
+    '-i',
+    start.streamUrl,
+    '-f',
+    's16le',
+    '-ac',
+    '2',
+    '-ar',
+    '44100',
+    'pipe:1'
+], {
+    stdio: ['ignore', 'pipe', 'pipe']
+});
+ffmpeg.stdout.on('data', chunk => {
+    airtunes.write(chunk);
+});
+ffmpeg.stderr.on('data', chunk => {
+    process.stderr.write(chunk);
+});
+ffmpeg.once('error', error => {
+    emit({ type: 'error', message: error.message });
+    stop(1);
+});
+ffmpeg.once('exit', code => {
+    if (!stopping) {
+        if (code !== 0) {
+            emit({ type: 'error', message: `ffmpeg exited with code ${code}` });
+        }
+        stop(code ?? 0);
+    }
+});
+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 === 'passcode') {
+        device.setPasscode?.(command.code);
+    }
+}
+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);
+    }
+    try {
+        return require('node-airtunes2');
+    }
+    catch {
+        emit({ type: 'error', message: 'AirPlay sender package could not be loaded after passing the safety gate.' });
+        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.killed) {
+        ffmpeg.kill('SIGTERM');
+    }
+    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 only; native playback comes from mpv, ffplay, or AirPlay prerequisites',
         `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
     ];
 }

package/dist/player/player-controller.js

@@ -1,9 +1,13 @@
 import { spawn } from 'node:child_process';
 import { existsSync, unlinkSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { Socket } from 'node:net';
-import { detectPlaybackBackends, playbackBackendInstallHint } from './backend-install.js';
+import { detectPlaybackBackends, ffplayLimitedControlsMessage, playbackBackendInstallHint } from './backend-install.js';
+import { discoverAirPlayDevices } from './airplay-discovery.js';
+import { airPlaySenderHealth } from './airplay-sender-health.js';
+import { encodeWorkerStart, parseWorkerMessage, serializeWorkerMessage } from './airplay-worker-protocol.js';
 export class PlayerController {
     getSettings;
     process = null;
@@ -15,6 +19,9 @@ export class PlayerController {
     listeners = new Set();
     metadataListeners = new Set();
     availableBackends = null;
+    availableAirPlayDevices = [];
+    airPlayReadyResolver = null;
+    airPlayReadyRejecter = null;
     nextMpvRequestId = 1;
     currentMpvMediaTitle = null;
     constructor(getSettings) {
@@ -57,9 +64,10 @@ export class PlayerController {
         await this.stop();
         const backend = this.selectBackend();
         if (!backend) {
-            throw new Error(`No playback backend found. ${playbackBackendInstallHint()}`);
+            throw new Error(this.playbackUnavailableMessage());
         }
         this.backend = backend;
+        let airPlayDeviceName;
         this.setState({
             backend,
             state: 'loading',
@@ -70,8 +78,30 @@ export class PlayerController {
             streamUrl: url,
             ready: false
         });
-        backend === 'mpv' ? this.playWithMpv(url, station.name) : this.playWithFfplay(url);
-        await this.waitForReady(backend);
+        if (backend === 'mpv') {
+            this.playWithMpv(url, station.name);
+            await this.waitForReady(backend);
+        }
+        else if (backend === 'ffplay') {
+            this.playWithFfplay(url);
+            await this.waitForReady(backend);
+        }
+        else {
+            const device = await this.resolveAirPlayDevice();
+            airPlayDeviceName = device.name;
+            this.setState({ ...this.state, airPlayDeviceName });
+            const result = await this.playWithAirPlay(url, station.name, device);
+            if (result === 'password-required') {
+                this.setState({
+                    ...this.state,
+                    backend,
+                    state: 'loading',
+                    message: 'AirPlay code required. Use :airplay-code 1234.',
+                    ready: false
+                });
+                return;
+            }
+        }
         this.setState({
             backend,
             state: 'playing',
@@ -79,6 +109,7 @@ export class PlayerController {
             volume: this.getSettings().volume,
             muted: false,
             stationName: station.name,
+            airPlayDeviceName,
             streamUrl: url,
             startedAt: new Date().toISOString(),
             ready: true
@@ -89,56 +120,71 @@ export class PlayerController {
     }
     async togglePause() {
         if (!this.process || !this.backend || !this.state.ready) {
-            return;
+            return { ok: false };
+        }
+        const unsupported = this.unsupportedFfplayControl();
+        if (unsupported) {
+            return unsupported;
         }
         if (this.backend === 'mpv') {
             await this.sendMpv({ command: ['cycle', 'pause'] }).catch(() => undefined);
             const synced = await this.syncMpvPlaybackState();
             if (synced) {
-                return;
+                return { ok: true };
             }
         }
-        else {
-            this.process.stdin.write('p');
+        else if (this.backend === 'airplay') {
+            this.setState({ ...this.state, message: 'AirPlay pause is not supported. Use :stop to end playback.' });
+            return { ok: false, message: 'AirPlay pause is not supported. Use :stop to end playback.' };
         }
         this.setState({
             ...this.state,
             state: this.state.state === 'paused' ? 'playing' : 'paused'
         });
+        return { ok: true };
     }
     async setVolume(volume) {
         const clamped = clampVolume(volume);
+        const unsupported = this.unsupportedFfplayControl();
+        if (unsupported) {
+            return unsupported;
+        }
         if (this.backend === 'mpv') {
             await this.sendMpv({ command: ['set_property', 'volume', clamped] }).catch(() => undefined);
         }
-        else if (this.backend === 'ffplay' && this.process) {
-            const delta = clamped - this.state.volume;
-            const key = delta > 0 ? '0' : '9';
-            const steps = Math.min(10, Math.ceil(Math.abs(delta) / 5));
-            for (let index = 0; index < steps; index += 1) {
-                this.process.stdin.write(key);
-            }
+        else if (this.backend === 'airplay') {
+            this.sendAirPlayCommand({ type: 'setVolume', volume: clamped });
         }
         this.setState({ ...this.state, volume: clamped });
+        return { ok: true };
     }
     async adjustVolume(delta) {
-        await this.setVolume(this.state.volume + delta);
+        return this.setVolume(this.state.volume + delta);
     }
     async toggleMute() {
         const muted = !this.state.muted;
+        const unsupported = this.unsupportedFfplayControl();
+        if (unsupported) {
+            return unsupported;
+        }
         if (this.backend === 'mpv') {
             await this.sendMpv({ command: ['set_property', 'mute', muted] }).catch(() => undefined);
         }
-        else if (this.backend === 'ffplay' && this.process) {
-            this.process.stdin.write('m');
+        else if (this.backend === 'airplay') {
+            this.sendAirPlayCommand({ type: 'setMuted', muted });
         }
         this.setState({ ...this.state, muted });
+        return { ok: true };
     }
     async stop() {
         this.stopMpvPolling();
+        this.rejectPendingAirPlayReady(new Error('AirPlay playback stopped.'));
         if (this.backend === 'mpv') {
             await this.sendMpv({ command: ['quit'] }).catch(() => undefined);
         }
+        else if (this.backend === 'airplay') {
+            this.sendAirPlayCommand({ type: 'stop' });
+        }
         if (this.process && !this.process.killed) {
             this.process.kill('SIGTERM');
         }
@@ -151,6 +197,25 @@ export class PlayerController {
             ready: false
         });
     }
+    submitAirPlayPasscode(code) {
+        if (this.backend !== 'airplay') {
+            return;
+        }
+        const trimmed = code.trim();
+        if (!trimmed || Buffer.byteLength(trimmed, 'utf8') > 64 || /[\u0000-\u001F\u007F-\u009F]/.test(trimmed)) {
+            this.setState({ ...this.state, message: 'AirPlay code must be 1-64 printable characters.' });
+            return;
+        }
+        this.sendAirPlayCommand({ type: 'passcode', code: trimmed });
+        this.setState({ ...this.state, message: 'AirPlay code sent.' });
+    }
+    async refreshAirPlayDevices() {
+        this.availableAirPlayDevices = await discoverAirPlayDevices();
+        return [...this.availableAirPlayDevices];
+    }
+    detectedAirPlayDevices() {
+        return [...this.availableAirPlayDevices];
+    }
     selectBackend() {
         const preferred = this.getSettings().preferredBackend;
         const backends = this.availableBackends ?? this.refreshDetectedBackends();
@@ -160,14 +225,30 @@ export class PlayerController {
         if (preferred === 'ffplay') {
             return backends.includes('ffplay') ? 'ffplay' : null;
         }
+        if (preferred === 'airplay') {
+            return backends.includes('airplay') ? 'airplay' : null;
+        }
         if (backends.includes('mpv')) {
             return 'mpv';
         }
         if (backends.includes('ffplay')) {
             return 'ffplay';
         }
+        if (backends.includes('airplay')) {
+            return 'airplay';
+        }
         return null;
     }
+    playbackUnavailableMessage() {
+        const preferred = this.getSettings().preferredBackend;
+        if (preferred === 'airplay') {
+            return `AirPlay backend unavailable. It requires macOS, ffmpeg, dns-sd, and a sender package that passes RadioCLI's dependency safety gate. ${airPlaySenderHealth().message}`;
+        }
+        if (preferred === 'mpv' || preferred === 'ffplay') {
+            return `Preferred playback backend ${preferred} is unavailable. ${playbackBackendInstallHint()}`;
+        }
+        return `No playback backend found. ${playbackBackendInstallHint()}`;
+    }
     playWithMpv(url, initialTitle) {
         this.ipcPath = createMpvIpcPath();
         this.currentMpvMediaTitle = cleanMediaTitle(initialTitle) ?? 'RadioCLI';
@@ -190,6 +271,96 @@ export class PlayerController {
         });
         this.wireProcess();
     }
+    async resolveAirPlayDevice() {
+        const devices = await this.refreshAirPlayDevices();
+        const preferred = this.getSettings().preferredAirPlayDevice;
+        const device = devices.find(candidate => candidate.id === preferred) ?? devices[0];
+        if (!device) {
+            throw new Error('No AirPlay receiver found. Make sure the receiver is on the same network.');
+        }
+        return device;
+    }
+    playWithAirPlay(url, stationName, device) {
+        const workerPath = airPlayWorkerPath();
+        const workerArgs = airPlayWorkerArgs(workerPath, encodeWorkerStart({
+            streamUrl: url,
+            stationName,
+            volume: this.getSettings().volume,
+            muted: false,
+            device
+        }));
+        this.process = spawn(process.execPath, workerArgs, {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.wireAirPlayProcess();
+        this.wireProcess();
+        const child = this.process;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.airPlayReadyResolver = null;
+                this.airPlayReadyRejecter = null;
+                const error = new Error(`Timed out while opening AirPlay stream after ${this.getSettings().tuneTimeoutSeconds}s.`);
+                this.stopAirPlayProcess(child);
+                this.setState({ ...this.state, backend: 'airplay', state: 'error', ready: false, message: error.message });
+                reject(error);
+            }, this.getSettings().tuneTimeoutSeconds * 1000);
+            this.airPlayReadyResolver = result => {
+                clearTimeout(timeout);
+                this.airPlayReadyResolver = null;
+                this.airPlayReadyRejecter = null;
+                resolve(result);
+            };
+            this.airPlayReadyRejecter = error => {
+                clearTimeout(timeout);
+                this.airPlayReadyResolver = null;
+                this.airPlayReadyRejecter = null;
+                reject(error);
+            };
+        });
+    }
+    wireAirPlayProcess() {
+        const child = this.process;
+        if (!child) {
+            return;
+        }
+        let buffer = '';
+        child.stdout.on('data', chunk => {
+            buffer += chunk.toString('utf8');
+            let newlineIndex = buffer.indexOf('\n');
+            while (newlineIndex !== -1) {
+                const line = buffer.slice(0, newlineIndex);
+                buffer = buffer.slice(newlineIndex + 1);
+                newlineIndex = buffer.indexOf('\n');
+                const event = parseWorkerMessage(line);
+                if (event) {
+                    this.handleAirPlayEvent(event);
+                }
+            }
+        });
+    }
+    handleAirPlayEvent(event) {
+        if (event.type === 'ready' || event.type === 'playing') {
+            this.airPlayReadyResolver?.('ready');
+            if (this.backend === 'airplay') {
+                this.setState({ ...this.state, backend: 'airplay', state: 'playing', ready: true, message: this.state.stationName });
+            }
+        }
+        else if (event.type === 'password-required') {
+            this.airPlayReadyResolver?.('password-required');
+            this.setState({ ...this.state, backend: 'airplay', state: 'loading', ready: false, message: 'AirPlay code required. Use :airplay-code 1234.' });
+        }
+        else if (event.type === 'error') {
+            const error = new Error(event.message);
+            this.airPlayReadyRejecter?.(error);
+            this.setState({ ...this.state, backend: 'airplay', state: 'error', ready: false, message: event.message });
+        }
+    }
+    unsupportedFfplayControl() {
+        if (this.backend === 'ffplay' && this.process) {
+            return { ok: false, message: ffplayLimitedControlsMessage };
+        }
+        return null;
+    }
     wireProcess() {
         const child = this.process;
         if (!child) {
@@ -222,6 +393,34 @@ export class PlayerController {
     sendMpv(payload) {
         return this.queryMpv(payload).then(() => undefined);
     }
+    sendAirPlayCommand(command) {
+        if (this.backend === 'airplay' && this.process && !this.process.killed) {
+            this.process.stdin.write(serializeWorkerMessage(command));
+        }
+    }
+    stopAirPlayProcess(child) {
+        if (!child) {
+            return;
+        }
+        if (!child.killed) {
+            try {
+                child.stdin.write(serializeWorkerMessage({ type: 'stop' }));
+            }
+            catch {
+                // The worker may already be exiting.
+            }
+            child.kill('SIGTERM');
+        }
+        if (this.process === child) {
+            this.process = null;
+        }
+    }
+    rejectPendingAirPlayReady(error) {
+        const rejecter = this.airPlayReadyRejecter;
+        this.airPlayReadyResolver = null;
+        this.airPlayReadyRejecter = null;
+        rejecter?.(error);
+    }
     queryMpv(payload) {
         if (!this.ipcPath) {
             return Promise.resolve(null);
@@ -398,6 +597,17 @@ export function createMpvIpcPath(platform = process.platform, pid = process.pid,
     }
     return join(tmpdir(), `radiocli-${pid}-${timestamp}.sock`);
 }
+function airPlayWorkerPath() {
+    const currentPath = fileURLToPath(import.meta.url);
+    const extension = currentPath.endsWith('.ts') || currentPath.endsWith('.tsx') ? '.ts' : '.js';
+    return join(dirname(currentPath), `airplay-worker${extension}`);
+}
+function airPlayWorkerArgs(workerPath, encodedStart) {
+    if (workerPath.endsWith('.ts')) {
+        return ['--import', 'tsx', workerPath, encodedStart];
+    }
+    return [workerPath, encodedStart];
+}
 function isWindowsNamedPipePath(path) {
     return path.startsWith('\\\\.\\pipe\\');
 }

package/dist/storage/store.js

@@ -136,7 +136,8 @@ const settingsSchema = z.object({
     volume: z.number().min(0).max(100).default(70),
     enableRadioGarden: z.boolean().default(false),
     enableNearbyLocation: z.boolean().default(false),
-    preferredBackend: z.enum(['auto', 'mpv', 'ffplay']).default('auto'),
+    preferredBackend: z.enum(['auto', 'mpv', 'ffplay', 'airplay']).default('auto'),
+    preferredAirPlayDevice: z.string().min(1).optional(),
     tuneTimeoutSeconds: z.number().min(3).max(45).default(12),
     skipBrokenStreams: z.boolean().default(true),
     mediaKeys: z