@ciphore/radiocli 0.1.2 → 0.1.4

package/dist/player/player-controller.js

@@ -1,9 +1,23 @@
 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';
+const minAirPlayTuneTimeoutSeconds = 30;
+export class PlaybackOutputError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PlaybackOutputError';
+    }
+}
+export function isPlaybackOutputError(error) {
+    return error instanceof PlaybackOutputError;
+}
 export class PlayerController {
     getSettings;
     process = null;
@@ -15,6 +29,17 @@ export class PlayerController {
     listeners = new Set();
     metadataListeners = new Set();
     availableBackends = null;
+    availableAirPlayDevices = [];
+    airPlayReadyResolver = null;
+    airPlayReadyRejecter = null;
+    airPlayRetuneResolver = null;
+    airPlayRetuneRejecter = null;
+    airPlayRetuning = false;
+    airPlaySessionEstablished = false;
+    airPlayPasscodes = new Map();
+    currentAirPlayDevice = null;
+    currentAirPlayDeviceId = null;
+    pendingAirPlayPasscode = null;
     nextMpvRequestId = 1;
     currentMpvMediaTitle = null;
     constructor(getSettings) {
@@ -54,11 +79,75 @@ export class PlayerController {
         return this.detectedBackends();
     }
     async play(station, url) {
-        await this.stop();
         const backend = this.selectBackend();
         if (!backend) {
-            throw new Error(`No playback backend found. ${playbackBackendInstallHint()}`);
+            await this.stop();
+            throw new PlaybackOutputError(this.playbackUnavailableMessage());
+        }
+        if (backend === 'airplay') {
+            const activeDevice = this.activeAirPlayDeviceForRetune();
+            if (activeDevice) {
+                await this.retuneAirPlay(url, station.name, activeDevice);
+                return;
+            }
+            let device;
+            try {
+                device = await this.resolveAirPlayDevice();
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Could not resolve AirPlay receiver.';
+                this.setState({ ...this.state, backend, state: 'error', message, ready: false });
+                throw error;
+            }
+            if (this.canRetuneAirPlay(device)) {
+                await this.retuneAirPlay(url, station.name, device);
+                return;
+            }
+            await this.stop();
+            this.backend = backend;
+            this.currentAirPlayDevice = device;
+            this.currentAirPlayDeviceId = device.id;
+            this.setState({
+                backend,
+                state: 'loading',
+                message: `Opening ${station.name}`,
+                volume: this.getSettings().volume,
+                muted: false,
+                stationName: station.name,
+                streamUrl: url,
+                ready: false
+            });
+            this.setState({ ...this.state, airPlayDeviceName: device.name });
+            const result = await this.playWithAirPlay(url, station.name, device);
+            if (result === 'password-required') {
+                if (this.pendingAirPlayPasscode) {
+                    return;
+                }
+                this.setState({
+                    ...this.state,
+                    backend,
+                    state: 'loading',
+                    message: 'AirPlay code required. Use :airplay-code 1234.',
+                    ready: false
+                });
+                return;
+            }
+            this.airPlaySessionEstablished = true;
+            this.setState({
+                backend,
+                state: 'playing',
+                message: station.name,
+                volume: this.getSettings().volume,
+                muted: false,
+                stationName: station.name,
+                airPlayDeviceName: device.name,
+                streamUrl: url,
+                startedAt: new Date().toISOString(),
+                ready: true
+            });
+            return;
         }
+        await this.stop();
         this.backend = backend;
         this.setState({
             backend,
@@ -70,8 +159,14 @@ 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);
+        }
         this.setState({
             backend,
             state: 'playing',
@@ -89,56 +184,76 @@ 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.'));
+        this.rejectPendingAirPlayRetune(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' });
+            this.currentAirPlayDevice = null;
+            this.currentAirPlayDeviceId = null;
+            this.pendingAirPlayPasscode = null;
+            this.airPlaySessionEstablished = false;
+        }
         if (this.process && !this.process.killed) {
             this.process.kill('SIGTERM');
         }
@@ -151,6 +266,31 @@ export class PlayerController {
             ready: false
         });
     }
+    submitAirPlayPasscode(code) {
+        if (this.backend !== 'airplay') {
+            return { ok: false, message: 'No active AirPlay playback is waiting for a code.' };
+        }
+        const trimmed = code.trim();
+        if (!trimmed || Buffer.byteLength(trimmed, 'utf8') > 64 || /[\u0000-\u001F\u007F-\u009F]/.test(trimmed)) {
+            const message = 'AirPlay code must be 1-64 printable characters.';
+            this.setState({ ...this.state, message });
+            return { ok: false, message };
+        }
+        if (!this.sendAirPlayCommand({ type: 'passcode', code: trimmed })) {
+            return { ok: false, message: 'No active AirPlay playback is waiting for a code.' };
+        }
+        this.pendingAirPlayPasscode = trimmed;
+        const message = 'AirPlay code sent.';
+        this.setState({ ...this.state, message });
+        return { ok: true, message };
+    }
+    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,6 +300,9 @@ 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';
         }
@@ -168,6 +311,16 @@ export class PlayerController {
         }
         return null;
     }
+    playbackUnavailableMessage() {
+        const preferred = this.getSettings().preferredBackend;
+        if (preferred === 'airplay') {
+            return `AirPlay is not ready on this install. Run radiocli doctor. ${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 +343,220 @@ export class PlayerController {
         });
         this.wireProcess();
     }
+    canRetuneAirPlay(device) {
+        return Boolean(this.backend === 'airplay' &&
+            this.process &&
+            !this.process.killed &&
+            this.airPlaySessionEstablished &&
+            this.currentAirPlayDeviceId === device.id);
+    }
+    activeAirPlayDeviceForRetune() {
+        const preferred = this.getSettings().preferredAirPlayDevice;
+        if (!this.currentAirPlayDevice || this.currentAirPlayDevice.id !== preferred || !this.canRetuneAirPlay(this.currentAirPlayDevice)) {
+            return null;
+        }
+        return this.currentAirPlayDevice;
+    }
+    retuneAirPlay(url, stationName, device) {
+        this.rejectPendingAirPlayRetune(new Error('AirPlay retune superseded.'));
+        this.airPlayRetuning = true;
+        this.setState({
+            ...this.state,
+            backend: 'airplay',
+            state: 'loading',
+            message: `Opening ${stationName}`,
+            stationName,
+            airPlayDeviceName: device.name,
+            streamUrl: url,
+            ready: false
+        });
+        if (!this.sendAirPlayCommand({ type: 'retune', streamUrl: url, stationName })) {
+            this.airPlayRetuning = false;
+            throw new PlaybackOutputError('AirPlay session is not available for retuning.');
+        }
+        return new Promise((resolve, reject) => {
+            const timeoutSeconds = this.airPlayTuneTimeoutSeconds();
+            const timeout = setTimeout(() => {
+                this.airPlayRetuneResolver = null;
+                this.airPlayRetuneRejecter = null;
+                this.airPlayRetuning = false;
+                const error = new PlaybackOutputError(`Timed out while switching AirPlay stream after ${timeoutSeconds}s. The receiver is still connected — pick another station or :stop.`);
+                // Keep the worker (and the paired receiver) alive so the next switch stays instant.
+                this.setState({ ...this.state, backend: 'airplay', state: 'error', ready: false, message: error.message });
+                reject(error);
+            }, timeoutSeconds * 1000);
+            this.airPlayRetuneResolver = () => {
+                clearTimeout(timeout);
+                this.airPlayRetuneResolver = null;
+                this.airPlayRetuneRejecter = null;
+                this.airPlayRetuning = false;
+                this.setState({
+                    ...this.state,
+                    backend: 'airplay',
+                    state: 'playing',
+                    message: stationName,
+                    stationName,
+                    airPlayDeviceName: device.name,
+                    streamUrl: url,
+                    startedAt: new Date().toISOString(),
+                    ready: true
+                });
+                resolve();
+            };
+            this.airPlayRetuneRejecter = error => {
+                clearTimeout(timeout);
+                this.airPlayRetuneResolver = null;
+                this.airPlayRetuneRejecter = null;
+                this.airPlayRetuning = false;
+                reject(error);
+            };
+        });
+    }
+    async resolveAirPlayDevice() {
+        const preferred = this.getSettings().preferredAirPlayDevice;
+        if (!preferred) {
+            throw new PlaybackOutputError('Choose an AirPlay receiver in Settings before tuning with AirPlay.');
+        }
+        const devices = await this.refreshAirPlayDevices();
+        const device = devices.find(candidate => candidate.id === preferred);
+        if (!device) {
+            throw new PlaybackOutputError('Selected AirPlay receiver was not found. Refresh AirPlay receivers in Settings.');
+        }
+        if (device.local) {
+            throw new PlaybackOutputError(`${device.name} is this Mac. Use Audio output: This device instead of AirPlay.`);
+        }
+        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 timeoutSeconds = this.airPlayTuneTimeoutSeconds();
+            const timeout = setTimeout(() => {
+                this.airPlayReadyResolver = null;
+                this.airPlayReadyRejecter = null;
+                const error = new PlaybackOutputError(`Timed out while opening AirPlay stream after ${timeoutSeconds}s.`);
+                this.stopAirPlayProcess(child);
+                this.setState({ ...this.state, backend: 'airplay', state: 'error', ready: false, message: error.message });
+                reject(error);
+            }, timeoutSeconds * 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;
+        }
+        child.stderr.on('data', () => {
+            // node-airtunes2 is noisy during pairing; drain stderr so the worker cannot block.
+        });
+        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);
+                }
+            }
+        });
+    }
+    airPlayTuneTimeoutSeconds() {
+        const configured = this.getSettings().tuneTimeoutSeconds;
+        return configured < 3 ? configured : Math.max(configured, minAirPlayTuneTimeoutSeconds);
+    }
+    cachedAirPlayPasscode() {
+        return this.currentAirPlayDeviceId ? this.airPlayPasscodes.get(this.currentAirPlayDeviceId) ?? null : null;
+    }
+    rememberPendingAirPlayPasscode() {
+        if (this.currentAirPlayDeviceId && this.pendingAirPlayPasscode) {
+            this.airPlayPasscodes.set(this.currentAirPlayDeviceId, this.pendingAirPlayPasscode);
+            this.pendingAirPlayPasscode = null;
+        }
+    }
+    handleAirPlayEvent(event) {
+        if (event.type === 'ready' || event.type === 'playing') {
+            if (this.airPlayRetuning) {
+                return;
+            }
+            this.airPlaySessionEstablished = true;
+            this.rememberPendingAirPlayPasscode();
+            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 === 'retuned') {
+            if (this.airPlayRetuneResolver) {
+                this.airPlayRetuneResolver();
+            }
+            else if (this.backend === 'airplay' && this.currentAirPlayDevice && this.state.state !== 'playing') {
+                // A retune that already timed out on our side eventually caught up; reflect live playback.
+                this.airPlayRetuning = false;
+                this.airPlaySessionEstablished = true;
+                this.setState({
+                    ...this.state,
+                    backend: 'airplay',
+                    state: 'playing',
+                    ready: true,
+                    message: this.state.stationName,
+                    startedAt: new Date().toISOString()
+                });
+            }
+        }
+        else if (event.type === 'password-required') {
+            const passcode = this.cachedAirPlayPasscode();
+            if (passcode) {
+                this.pendingAirPlayPasscode = passcode;
+                this.sendAirPlayCommand({ type: 'passcode', code: passcode });
+                this.setState({ ...this.state, backend: 'airplay', state: 'loading', ready: false, message: 'AirPlay code sent.' });
+                return;
+            }
+            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') {
+            this.pendingAirPlayPasscode = null;
+            const error = new PlaybackOutputError(event.message);
+            this.airPlayReadyRejecter?.(error);
+            this.rejectPendingAirPlayRetune(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) {
@@ -206,6 +573,13 @@ export class PlayerController {
         });
         child.on('exit', code => {
             if (this.process === child) {
+                this.rejectPendingAirPlayRetune(new Error('AirPlay worker exited.'));
+                if (this.backend === 'airplay') {
+                    this.currentAirPlayDevice = null;
+                    this.currentAirPlayDeviceId = null;
+                    this.pendingAirPlayPasscode = null;
+                    this.airPlaySessionEstablished = false;
+                }
                 this.process = null;
                 this.stopMpvPolling();
                 this.cleanupIpc();
@@ -222,6 +596,48 @@ export class PlayerController {
     sendMpv(payload) {
         return this.queryMpv(payload).then(() => undefined);
     }
+    sendAirPlayCommand(command) {
+        if (this.backend === 'airplay' && this.process && !this.process.killed) {
+            try {
+                this.process.stdin.write(serializeWorkerMessage(command));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+        return false;
+    }
+    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);
+    }
+    rejectPendingAirPlayRetune(error) {
+        const rejecter = this.airPlayRetuneRejecter;
+        this.airPlayRetuneResolver = null;
+        this.airPlayRetuneRejecter = null;
+        this.airPlayRetuning = false;
+        rejecter?.(error);
+    }
     queryMpv(payload) {
         if (!this.ipcPath) {
             return Promise.resolve(null);
@@ -398,6 +814,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
@@ -294,7 +295,7 @@ export class JsonLibraryStore {
     }
     write() {
         mkdirSync(dirname(this.filePath), { recursive: true });
-        writeJsonAtomically(this.filePath, this.state);
+        writeJsonAtomically(this.filePath, libraryStateForDisk(this.state));
     }
 }
 export function stationKey(station) {
@@ -344,18 +345,27 @@ function defaultState() {
     };
 }
 function migrateLibraryState(state) {
-    if (state.settings.receiverStyleVersion === 2) {
-        return state;
-    }
     return {
         ...state,
         settings: {
             ...state.settings,
-            receiverStyle: defaultReceiverStyle,
+            preferredBackend: state.settings.preferredBackend === 'airplay' ? 'auto' : state.settings.preferredBackend,
+            receiverStyle: state.settings.receiverStyleVersion === 2 ? state.settings.receiverStyle : defaultReceiverStyle,
             receiverStyleVersion: 2
         }
     };
 }
+function libraryStateForDisk(state) {
+    return state.settings.preferredBackend === 'airplay'
+        ? {
+            ...state,
+            settings: {
+                ...state.settings,
+                preferredBackend: 'auto'
+            }
+        }
+        : state;
+}
 function writeJsonAtomically(filePath, value) {
     const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
     try {