@ciphore/radiocli 0.1.3 → 0.1.5

package/dist/player/player-controller.js

@@ -8,6 +8,16 @@ import { detectPlaybackBackends, ffplayLimitedControlsMessage, playbackBackendIn
 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;
@@ -22,6 +32,14 @@ export class PlayerController {
     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) {
@@ -61,13 +79,76 @@ export class PlayerController {
         return this.detectedBackends();
     }
     async play(station, url) {
-        await this.stop();
         const backend = this.selectBackend();
         if (!backend) {
-            throw new Error(this.playbackUnavailableMessage());
+            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;
-        let airPlayDeviceName;
         this.setState({
             backend,
             state: 'loading',
@@ -86,22 +167,6 @@ export class PlayerController {
             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',
@@ -109,7 +174,6 @@ export class PlayerController {
             volume: this.getSettings().volume,
             muted: false,
             stationName: station.name,
-            airPlayDeviceName,
             streamUrl: url,
             startedAt: new Date().toISOString(),
             ready: true
@@ -179,11 +243,16 @@ export class PlayerController {
     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');
@@ -199,15 +268,21 @@ export class PlayerController {
     }
     submitAirPlayPasscode(code) {
         if (this.backend !== 'airplay') {
-            return;
+            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)) {
-            this.setState({ ...this.state, message: 'AirPlay code must be 1-64 printable characters.' });
-            return;
+            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.sendAirPlayCommand({ type: 'passcode', code: trimmed });
-        this.setState({ ...this.state, message: 'AirPlay code sent.' });
+        this.pendingAirPlayPasscode = trimmed;
+        const message = 'AirPlay code sent.';
+        this.setState({ ...this.state, message });
+        return { ok: true, message };
     }
     async refreshAirPlayDevices() {
         this.availableAirPlayDevices = await discoverAirPlayDevices();
@@ -234,15 +309,12 @@ export class PlayerController {
         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}`;
+            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()}`;
@@ -271,12 +343,87 @@ 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 devices = await this.refreshAirPlayDevices();
         const preferred = this.getSettings().preferredAirPlayDevice;
-        const device = devices.find(candidate => candidate.id === preferred) ?? devices[0];
+        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 Error('No AirPlay receiver found. Make sure the receiver is on the same network.');
+            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;
     }
@@ -296,14 +443,15 @@ export class PlayerController {
         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 Error(`Timed out while opening AirPlay stream after ${this.getSettings().tuneTimeoutSeconds}s.`);
+                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);
-            }, this.getSettings().tuneTimeoutSeconds * 1000);
+            }, timeoutSeconds * 1000);
             this.airPlayReadyResolver = result => {
                 clearTimeout(timeout);
                 this.airPlayReadyResolver = null;
@@ -323,6 +471,9 @@ export class PlayerController {
         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');
@@ -338,20 +489,65 @@ export class PlayerController {
             }
         });
     }
+    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') {
-            const error = new Error(event.message);
+            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 });
         }
     }
@@ -377,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();
@@ -395,8 +598,15 @@ export class PlayerController {
     }
     sendAirPlayCommand(command) {
         if (this.backend === 'airplay' && this.process && !this.process.killed) {
-            this.process.stdin.write(serializeWorkerMessage(command));
+            try {
+                this.process.stdin.write(serializeWorkerMessage(command));
+                return true;
+            }
+            catch {
+                return false;
+            }
         }
+        return false;
     }
     stopAirPlayProcess(child) {
         if (!child) {
@@ -421,6 +631,13 @@ export class PlayerController {
         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);

package/dist/storage/store.js

@@ -295,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) {
@@ -345,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 {