@ciphore/radiocli 0.1.9 → 0.2.1

package/dist/cli.js

@@ -8,7 +8,10 @@ import { PlayerController } from './player/player-controller.js';
 import { JsonLibraryStore } from './storage/store.js';
 import { parsePlaylistFile, stationFromUrl, writeM3u } from './playlists/playlist.js';
 import { detectPlaybackBackends, playbackBackendStatusLines } from './player/backend-install.js';
+import { resolveCommand } from './player/command.js';
+import { airPlaySenderHealth } from './player/airplay-sender-health.js';
 import { appVersion } from './version.js';
+import { checkForUpdate, updateCommandForInstall } from './update-check.js';
 if (isDirectRun(process.argv[1], import.meta.url)) {
     const args = process.argv.slice(2);
     if (args.length > 0) {
@@ -20,7 +23,8 @@ if (isDirectRun(process.argv[1], import.meta.url)) {
     else {
         const [{ render }, { App }] = await Promise.all([import('ink'), import('./ui/App.js')]);
         render(_jsx(App, {}), {
-            exitOnCtrlC: true,
+            // App owns Ctrl+C so it can confirm before performing a clean shutdown.
+            exitOnCtrlC: false,
             kittyKeyboard: {
                 mode: 'auto',
                 flags: ['disambiguateEscapeCodes', 'reportEventTypes', 'reportAllKeysAsEscapeCodes']
@@ -43,10 +47,28 @@ export async function runCommand(args) {
     }
     if (command === 'doctor') {
         const backends = detectPlaybackBackends();
+        if (rest.includes('--json')) {
+            console.log(JSON.stringify(doctorReport(backends), null, 2));
+            return;
+        }
         console.log(`backends=${backends.join(',') || 'none'}`);
         printPlaybackBackendStatus(backends);
         return;
     }
+    if (command === 'update') {
+        const updateCheck = await checkForUpdate();
+        const updateCommand = updateCommandForInstall();
+        if (updateCheck.error) {
+            console.log(`update_check=failed ${updateCheck.error}`);
+        }
+        else {
+            console.log(`installed=${appVersion()}`);
+            console.log(`latest=${updateCheck.latestVersion ?? 'unknown'}`);
+            console.log(`available=${updateCheck.updateAvailable ? 'yes' : 'no'}`);
+        }
+        console.log(`command=${updateCommand.command}`);
+        return;
+    }
     if (command === 'check') {
         const store = new JsonLibraryStore();
         const providers = new ProviderManager();
@@ -120,7 +142,8 @@ Usage:
   radiocli                 Start the TUI
   radiocli version         Print the installed version
   radiocli check           Show provider/backend health
-  radiocli doctor          Show local playback setup guidance
+  radiocli doctor [--json] Show local playback setup guidance
+  radiocli update          Show update availability and install command
   radiocli countries       Print top countries
   radiocli search <query>  Search public stations
   radiocli import <file>   Import .m3u, .pls, or .xspf streams
@@ -140,10 +163,37 @@ export function isDirectRun(entryPath, moduleUrl) {
     }
 }
 function isKnownCommand(command) {
-    return ['check', 'doctor', 'countries', 'search', 'import', 'export', 'add-url'].includes(command);
+    return ['check', 'doctor', 'update', 'countries', 'search', 'import', 'export', 'add-url'].includes(command);
 }
 function printPlaybackBackendStatus(backends) {
     for (const line of playbackBackendStatusLines(backends)) {
         console.log(line);
     }
 }
+function doctorReport(backends) {
+    const commands = Object.fromEntries(['mpv', 'ffplay', 'vlc', 'cvlc', 'ffmpeg', 'dns-sd'].map(command => [command, redactHome(resolveCommand(command))]));
+    const airPlay = airPlaySenderHealth();
+    return {
+        radioCliVersion: appVersion(),
+        nodeVersion: process.version,
+        platform: process.platform,
+        architecture: process.arch,
+        backends,
+        commands,
+        airPlay: {
+            available: airPlay.available,
+            safe: airPlay.safe,
+            package: airPlay.packageName,
+            version: airPlay.version ?? null,
+            vulnerablePackages: airPlay.vulnerablePackages,
+            warningPackages: airPlay.warningPackages
+        },
+        guidance: playbackBackendStatusLines(backends)
+    };
+}
+function redactHome(path) {
+    if (!path)
+        return null;
+    const home = process.env.HOME ?? process.env.USERPROFILE;
+    return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}

package/dist/player/airplay-discovery.js

@@ -129,9 +129,23 @@ function runDnsSd(args, timeoutMs, maxOutputBytes) {
         const child = spawn('dns-sd', args, { stdio: ['ignore', 'pipe', 'pipe'] });
         let output = '';
         let killedForLimit = false;
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(forceTimer);
+            resolve(output);
+        };
         const timer = setTimeout(() => {
             child.kill('SIGTERM');
+            setTimeout(() => {
+                if (child.exitCode === null)
+                    child.kill('SIGKILL');
+            }, 250).unref();
         }, timeoutMs);
+        const forceTimer = setTimeout(finish, timeoutMs + 750);
         const appendOutput = (chunk) => {
             if (Buffer.byteLength(output, 'utf8') >= maxOutputBytes) {
                 if (!killedForLimit) {
@@ -150,12 +164,10 @@ function runDnsSd(args, timeoutMs, maxOutputBytes) {
             appendOutput(chunk);
         });
         child.once('error', () => {
-            clearTimeout(timer);
-            resolve(output);
+            finish();
         });
         child.once('exit', () => {
-            clearTimeout(timer);
-            resolve(output);
+            finish();
         });
     });
 }

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

@@ -40,6 +40,7 @@ function validateWorkerStart(value) {
         : [];
     return {
         streamUrl: boundedHttpUrl(value.streamUrl, 'streamUrl'),
+        ffmpegPath: boundedString(value.ffmpegPath, 'ffmpegPath', 4096),
         stationName: boundedText(value.stationName, 'stationName', maxWorkerTextBytes),
         volume: clampVolume(Number(value.volume)),
         muted: typeof value.muted === 'boolean' ? value.muted : false,

package/dist/player/airplay-worker.js

@@ -108,7 +108,7 @@ function handleCommand(command) {
 }
 function startFfmpeg(streamUrl) {
     const previous = ffmpeg;
-    const child = spawn('ffmpeg', [
+    const child = spawn(start.ffmpegPath, [
         '-hide_banner',
         '-loglevel',
         'error',
@@ -208,7 +208,10 @@ function stop(code) {
         ffmpeg.kill('SIGTERM');
     }
     ffmpeg = null;
+    const watchdog = setTimeout(() => process.exit(code), 1500);
+    watchdog.unref();
     airtunes.stopAll(() => {
+        clearTimeout(watchdog);
         emit({ type: 'stopped' });
         process.exit(code);
     });

package/dist/player/command.js

@@ -1,5 +1,4 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { accessSync, constants, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 export function commandExists(command) {
@@ -11,23 +10,31 @@ export function commandExists(command) {
 // package-manager shim looks "missing" to a bare PATH lookup. We therefore fall
 // back to probing well-known install locations before giving up.
 export function resolveCommand(command) {
-    return lookupOnPath(command) ?? probeKnownLocations(command);
+    const cached = commandCache.get(command);
+    if (cached && Date.now() - cached.checkedAt < commandCacheTtlMs) {
+        return cached.path;
+    }
+    const path = lookupOnPath(command) ?? probeKnownLocations(command);
+    commandCache.set(command, { path, checkedAt: Date.now() });
+    return path;
 }
 function lookupOnPath(command) {
-    const lookup = process.platform === 'win32' ? 'where' : 'which';
-    const result = spawnSync(lookup, [command], { encoding: 'utf8' });
-    if (result.status !== 0 || typeof result.stdout !== 'string') {
-        return null;
+    if (command.includes('/') || command.includes('\\')) {
+        return isRunnable(command) ? command : null;
+    }
+    const pathEntries = (process.env.PATH ?? '').split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+    for (const directory of pathEntries) {
+        for (const name of candidateNames(command)) {
+            const candidate = join(directory.replace(/^"|"$/g, ''), name);
+            if (isRunnable(candidate))
+                return candidate;
+        }
     }
-    const first = result.stdout
-        .split(/\r?\n/)
-        .map(line => line.trim())
-        .find(Boolean);
-    return first ?? null;
+    return null;
 }
 function probeKnownLocations(command) {
     for (const candidate of candidatePaths(command)) {
-        if (existsSync(candidate)) {
+        if (isRunnable(candidate)) {
             return candidate;
         }
     }
@@ -46,10 +53,26 @@ function candidatePaths(command) {
 }
 function candidateNames(command) {
     if (process.platform === 'win32' && !/\.[a-z0-9]+$/i.test(command)) {
-        return [`${command}.exe`, `${command}.com`, `${command}.bat`, `${command}.cmd`, command];
+        const extensions = (process.env.PATHEXT ?? '.EXE;.COM;.BAT;.CMD').split(';').filter(Boolean);
+        return [...extensions.map(extension => `${command}${extension.toLowerCase()}`), command];
     }
     return [command];
 }
+const commandCacheTtlMs = 5000;
+const commandCache = new Map();
+function isRunnable(path) {
+    if (!existsSync(path))
+        return false;
+    if (process.platform === 'win32')
+        return true;
+    try {
+        accessSync(path, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function knownBinaryDirs() {
     const home = homedir();
     if (process.platform === 'darwin') {

package/dist/player/mpv-ipc-client.js

@@ -0,0 +1,194 @@
+import { Socket } from 'node:net';
+/**
+ * Multiplexes mpv JSON IPC requests over one reusable socket.
+ *
+ * mpv may also emit unsolicited event objects on this connection; responses
+ * are therefore matched strictly by request_id. A dropped connection rejects
+ * every in-flight request, while the next query reconnects lazily.
+ */
+export class MpvIpcClient {
+    path;
+    timeoutMs;
+    socket = null;
+    connectingSocket = null;
+    connecting = null;
+    pending = new Map();
+    buffer = '';
+    nextRequestId = 1;
+    closed = false;
+    constructor(path, timeoutMs = 1000) {
+        this.path = path;
+        this.timeoutMs = timeoutMs;
+    }
+    async query(payload) {
+        if (this.closed) {
+            throw new Error('mpv IPC client is closed.');
+        }
+        const socket = await this.connect();
+        const requestId = this.allocateRequestId();
+        const requestPayload = attachMpvRequestId(payload, requestId);
+        const message = `${JSON.stringify(requestPayload)}\n`;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.settleRequest(requestId, pending => pending.reject(new Error('mpv IPC timed out.')));
+            }, this.timeoutMs);
+            this.pending.set(requestId, {
+                resolve: value => resolve((value ?? null)),
+                reject,
+                timeout
+            });
+            try {
+                socket.write(message, error => {
+                    if (error) {
+                        this.settleRequest(requestId, pending => pending.reject(error));
+                    }
+                });
+            }
+            catch (error) {
+                this.settleRequest(requestId, pending => pending.reject(error instanceof Error ? error : new Error('mpv IPC write failed.')));
+            }
+        });
+    }
+    close(reason = new Error('mpv IPC connection closed.')) {
+        if (this.closed) {
+            return;
+        }
+        this.closed = true;
+        this.rejectPending(reason);
+        this.socket?.destroy();
+        this.connectingSocket?.destroy();
+        this.socket = null;
+        this.connectingSocket = null;
+        this.connecting = null;
+        this.buffer = '';
+    }
+    connect() {
+        if (this.socket && !this.socket.destroyed) {
+            return Promise.resolve(this.socket);
+        }
+        if (this.connecting) {
+            return this.connecting;
+        }
+        const socket = new Socket();
+        this.connectingSocket = socket;
+        const connecting = new Promise((resolve, reject) => {
+            let settled = false;
+            const connectionTimeout = setTimeout(() => failConnection(new Error('mpv IPC connection timed out.')), this.timeoutMs);
+            const closeBeforeConnection = () => failConnection(new Error('mpv IPC connection closed before it was ready.'));
+            const failConnection = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(connectionTimeout);
+                socket.off('connect', finishConnection);
+                socket.off('close', closeBeforeConnection);
+                socket.destroy();
+                reject(error);
+            };
+            const finishConnection = () => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(connectionTimeout);
+                socket.off('error', failConnection);
+                socket.off('close', closeBeforeConnection);
+                if (this.closed) {
+                    socket.destroy();
+                    reject(new Error('mpv IPC client is closed.'));
+                    return;
+                }
+                this.socket = socket;
+                this.connectingSocket = null;
+                this.buffer = '';
+                socket.on('data', chunk => this.consume(chunk.toString('utf8')));
+                socket.on('error', error => this.dropSocket(socket, error));
+                socket.on('close', () => this.dropSocket(socket, new Error('mpv IPC connection closed.')));
+                resolve(socket);
+            };
+            socket.once('error', failConnection);
+            socket.once('close', closeBeforeConnection);
+            socket.once('connect', finishConnection);
+            socket.connect(this.path);
+        });
+        let trackedConnection;
+        trackedConnection = connecting.finally(() => {
+            if (this.connecting === trackedConnection) {
+                this.connecting = null;
+            }
+            if (this.connectingSocket === socket && !this.socket) {
+                this.connectingSocket = null;
+            }
+        });
+        this.connecting = trackedConnection;
+        return trackedConnection;
+    }
+    consume(chunk) {
+        this.buffer += chunk;
+        let newlineIndex = this.buffer.indexOf('\n');
+        while (newlineIndex !== -1) {
+            const line = this.buffer.slice(0, newlineIndex);
+            this.buffer = this.buffer.slice(newlineIndex + 1);
+            newlineIndex = this.buffer.indexOf('\n');
+            if (!line.trim()) {
+                continue;
+            }
+            let response;
+            try {
+                response = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof response.request_id !== 'number' || !this.pending.has(response.request_id)) {
+                continue;
+            }
+            if (response.error && response.error !== 'success') {
+                this.settleRequest(response.request_id, pending => pending.reject(new Error(`mpv IPC failed: ${response.error}`)));
+            }
+            else {
+                this.settleRequest(response.request_id, pending => pending.resolve(response.data));
+            }
+        }
+    }
+    dropSocket(socket, error) {
+        if (this.socket !== socket) {
+            return;
+        }
+        this.socket = null;
+        this.buffer = '';
+        this.rejectPending(error);
+    }
+    rejectPending(error) {
+        for (const requestId of [...this.pending.keys()]) {
+            this.settleRequest(requestId, pending => pending.reject(error));
+        }
+    }
+    settleRequest(requestId, settle) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            return;
+        }
+        this.pending.delete(requestId);
+        clearTimeout(pending.timeout);
+        settle(pending);
+    }
+    allocateRequestId() {
+        while (this.pending.has(this.nextRequestId)) {
+            this.nextRequestId = incrementRequestId(this.nextRequestId);
+        }
+        const requestId = this.nextRequestId;
+        this.nextRequestId = incrementRequestId(this.nextRequestId);
+        return requestId;
+    }
+}
+function attachMpvRequestId(payload, requestId) {
+    if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
+        return { ...payload, request_id: requestId };
+    }
+    return { command: payload, request_id: requestId };
+}
+function incrementRequestId(requestId) {
+    return requestId >= Number.MAX_SAFE_INTEGER ? 1 : requestId + 1;
+}