@ciphore/radiocli 0.2.1 → 0.2.3

package/dist/player/command.js

@@ -1,69 +1,93 @@
+import { spawnSync } from 'node:child_process';
 import { accessSync, constants, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { posix, win32 } from 'node:path';
 export function commandExists(command) {
     return resolveCommand(command) !== null;
 }
 // Resolve a runnable path for a command. GUI-launched terminals (macOS .app
 // terminals, some Linux desktop launchers) frequently do not inherit the login
-// shell PATH, so a perfectly installed binary in /opt/homebrew/bin or a Windows
-// package-manager shim looks "missing" to a bare PATH lookup. We therefore fall
-// back to probing well-known install locations before giving up.
+// shell PATH, while Windows installers often omit PATH entries entirely.
 export function resolveCommand(command) {
-    const cached = commandCache.get(command);
-    if (cached && Date.now() - cached.checkedAt < commandCacheTtlMs) {
-        return cached.path;
+    return resolveCommandDetails(command).path;
+}
+export function resolveCommandDetails(command, overrides) {
+    if (!overrides) {
+        const cached = commandCache.get(command);
+        if (cached && Date.now() - cached.checkedAt < commandCacheTtlMs)
+            return cached.resolution;
     }
-    const path = lookupOnPath(command) ?? probeKnownLocations(command);
-    commandCache.set(command, { path, checkedAt: Date.now() });
-    return path;
+    const platform = overrides?.platform ?? process.platform;
+    const options = {
+        platform,
+        env: overrides?.env ?? process.env,
+        home: overrides?.home ?? homedir(),
+        isRunnable: overrides?.isRunnable ?? (path => isRunnable(path, platform)),
+        registryPaths: overrides?.registryPaths ?? (name => windowsRegistryPaths(name, platform))
+    };
+    const resolution = resolveUncached(command, options);
+    if (!overrides)
+        commandCache.set(command, { resolution, checkedAt: Date.now() });
+    return resolution;
 }
-function lookupOnPath(command) {
-    if (command.includes('/') || command.includes('\\')) {
-        return isRunnable(command) ? command : null;
+function resolveUncached(command, options) {
+    const pathMatch = lookupOnPath(command, options);
+    if (pathMatch)
+        return { path: pathMatch, discovery: 'path' };
+    const shimMatch = firstRunnable(knownBinaryCandidates(command, options), options.isRunnable);
+    if (shimMatch)
+        return { path: shimMatch, discovery: 'package-manager-shim' };
+    const appMatch = firstRunnable(applicationCandidates(command, options), options.isRunnable);
+    if (appMatch)
+        return { path: appMatch, discovery: 'application-directory' };
+    if (options.platform === 'win32') {
+        const registryMatch = firstRunnable(options.registryPaths(command), options.isRunnable);
+        if (registryMatch)
+            return { path: registryMatch, discovery: 'windows-registry' };
     }
-    const pathEntries = (process.env.PATH ?? '').split(process.platform === 'win32' ? ';' : ':').filter(Boolean);
+    return { path: null, discovery: 'missing' };
+}
+function lookupOnPath(command, options) {
+    if (command.includes('/') || command.includes('\\'))
+        return options.isRunnable(command) ? command : null;
+    const pathApi = options.platform === 'win32' ? win32 : posix;
+    const separator = options.platform === 'win32' ? ';' : ':';
+    const pathEntries = (options.env.PATH ?? '').split(separator).filter(Boolean);
     for (const directory of pathEntries) {
-        for (const name of candidateNames(command)) {
-            const candidate = join(directory.replace(/^"|"$/g, ''), name);
-            if (isRunnable(candidate))
+        for (const name of candidateNames(command, options.platform, options.env)) {
+            const candidate = pathApi.join(directory.replace(/^"|"$/g, ''), name);
+            if (options.isRunnable(candidate))
                 return candidate;
         }
     }
     return null;
 }
-function probeKnownLocations(command) {
-    for (const candidate of candidatePaths(command)) {
-        if (isRunnable(candidate)) {
-            return candidate;
-        }
-    }
-    return null;
-}
-function candidatePaths(command) {
-    const paths = [];
-    const names = candidateNames(command);
-    for (const dir of knownBinaryDirs()) {
-        for (const name of names) {
-            paths.push(join(dir, name));
+function knownBinaryCandidates(command, options) {
+    const pathApi = options.platform === 'win32' ? win32 : posix;
+    const candidates = [];
+    for (const directory of knownBinaryDirs(options)) {
+        for (const name of candidateNames(command, options.platform, options.env)) {
+            candidates.push(pathApi.join(directory, name));
         }
     }
-    paths.push(...appBundlePaths(command));
-    return paths;
+    return candidates;
 }
-function candidateNames(command) {
-    if (process.platform === 'win32' && !/\.[a-z0-9]+$/i.test(command)) {
-        const extensions = (process.env.PATHEXT ?? '.EXE;.COM;.BAT;.CMD').split(';').filter(Boolean);
+function candidateNames(command, platform, env) {
+    if (platform === 'win32' && !/\.[a-z0-9]+$/i.test(command)) {
+        const extensions = (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) {
+export function clearCommandCache() {
+    commandCache.clear();
+}
+function isRunnable(path, platform) {
     if (!existsSync(path))
         return false;
-    if (process.platform === 'win32')
+    if (platform === 'win32')
         return true;
     try {
         accessSync(path, constants.X_OK);
@@ -73,20 +97,17 @@ function isRunnable(path) {
         return false;
     }
 }
-function knownBinaryDirs() {
-    const home = homedir();
-    if (process.platform === 'darwin') {
-        return ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/opt/local/bin', '/sw/bin', join(home, '.local', 'bin')];
+function knownBinaryDirs({ platform, env, home }) {
+    if (platform === 'darwin') {
+        return ['/opt/homebrew/bin', '/usr/local/bin', '/usr/bin', '/opt/local/bin', '/sw/bin', posix.join(home, '.local', 'bin')];
     }
-    if (process.platform === 'win32') {
+    if (platform === 'win32') {
         const dirs = [];
-        if (process.env.LOCALAPPDATA) {
-            dirs.push(join(process.env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links'));
-        }
-        dirs.push(join(home, 'scoop', 'shims'));
-        if (process.env.ProgramData) {
-            dirs.push(join(process.env.ProgramData, 'chocolatey', 'bin'));
-        }
+        if (env.LOCALAPPDATA)
+            dirs.push(win32.join(env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links'));
+        dirs.push(win32.join(home, 'scoop', 'shims'));
+        if (env.ProgramData)
+            dirs.push(win32.join(env.ProgramData, 'chocolatey', 'bin'));
         return dirs;
     }
     return [
@@ -96,24 +117,64 @@ function knownBinaryDirs() {
         '/usr/local/sbin',
         '/snap/bin',
         '/var/lib/flatpak/exports/bin',
-        join(home, '.local', 'bin')
+        posix.join(home, '.local', 'bin')
     ];
 }
-// Some media players (notably VLC) commonly install without putting a CLI entry
-// on PATH, so probe their standard application directories directly.
-function appBundlePaths(command) {
-    if (command !== 'vlc' && command !== 'cvlc') {
-        return [];
-    }
-    if (process.platform === 'darwin') {
+// Media-player installers commonly skip PATH. Probe only their documented,
+// narrow install locations so startup stays fast and filesystem access bounded.
+function applicationCandidates(command, { platform, env, home }) {
+    if ((command === 'vlc' || command === 'cvlc') && platform === 'darwin') {
         return [
             '/Applications/VLC.app/Contents/MacOS/VLC',
-            join(homedir(), 'Applications', 'VLC.app', 'Contents', 'MacOS', 'VLC')
+            posix.join(home, 'Applications', 'VLC.app', 'Contents', 'MacOS', 'VLC')
         ];
     }
-    if (process.platform === 'win32') {
-        const roots = [process.env.ProgramFiles, process.env['ProgramFiles(x86)']].filter(Boolean);
-        return roots.map(root => join(root, 'VideoLAN', 'VLC', 'vlc.exe'));
+    if (platform !== 'win32')
+        return [];
+    if (command === 'vlc' || command === 'cvlc') {
+        return windowsProgramRoots(env).map(root => win32.join(root, 'VideoLAN', 'VLC', 'vlc.exe'));
+    }
+    if (command === 'mpv') {
+        const candidates = windowsProgramRoots(env).flatMap(root => [
+            win32.join(root, 'MPV Player', 'mpv.exe'),
+            win32.join(root, 'MPV', 'mpv.exe'),
+            win32.join(root, 'mpv', 'mpv.exe')
+        ]);
+        if (env.LOCALAPPDATA) {
+            candidates.push(win32.join(env.LOCALAPPDATA, 'Programs', 'MPV Player', 'mpv.exe'), win32.join(env.LOCALAPPDATA, 'Programs', 'MPV', 'mpv.exe'), win32.join(env.LOCALAPPDATA, 'mpv', 'mpv.exe'));
+        }
+        return candidates;
     }
     return [];
 }
+function windowsProgramRoots(env) {
+    return [env.ProgramFiles, env['ProgramFiles(x86)']].filter((root) => Boolean(root));
+}
+function windowsRegistryPaths(command, platform) {
+    if (platform !== 'win32' || command !== 'mpv')
+        return [];
+    const paths = [
+        queryRegistryPath('HKCU\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\mpv.exe', '/ve'),
+        queryRegistryPath('HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\mpv.exe', '/ve'),
+        queryRegistryPath('HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\MPV_Player_Automated_is1', '/v', 'InstallLocation')
+    ];
+    return paths.flatMap(path => path ? [path.toLowerCase().endsWith('.exe') ? path : win32.join(path, 'mpv.exe')] : []);
+}
+function queryRegistryPath(key, ...args) {
+    const result = spawnSync('reg.exe', ['query', key, ...args], {
+        encoding: 'utf8',
+        timeout: 1000,
+        windowsHide: true
+    });
+    if (result.error || result.status !== 0)
+        return null;
+    const match = result.stdout.match(/REG_(?:EXPAND_)?SZ\s+(.+)$/m);
+    return match?.[1]?.trim() || null;
+}
+function firstRunnable(paths, isRunnablePath) {
+    for (const path of paths) {
+        if (isRunnablePath(path))
+            return path;
+    }
+    return null;
+}

package/dist/player/player-controller.js

@@ -50,6 +50,7 @@ export class PlayerController {
     mpvVolumeFlush = null;
     confirmedMpvVolume = 70;
     mpvSessionId = 0;
+    stopPromise = null;
     constructor(getSettings) {
         this.getSettings = getSettings;
     }
@@ -229,6 +230,20 @@ export class PlayerController {
         });
         return { ok: true };
     }
+    async pause() {
+        if (this.state.state === 'paused')
+            return { ok: true };
+        if (this.state.state !== 'playing')
+            return { ok: false, message: 'RadioCLI is not currently playing.' };
+        return this.togglePause();
+    }
+    async resume() {
+        if (this.state.state === 'playing')
+            return { ok: true };
+        if (this.state.state !== 'paused')
+            return { ok: false, message: 'RadioCLI has no paused station to resume.' };
+        return this.togglePause();
+    }
     setVolume(volume) {
         const clamped = clampVolume(volume);
         const unsupported = this.unsupportedFfplayControl();
@@ -271,12 +286,27 @@ export class PlayerController {
         this.setState({ ...this.state, muted });
         return { ok: true };
     }
-    async stop() {
+    async setMuted(muted) {
+        if (this.state.muted === muted)
+            return { ok: true };
+        return this.toggleMute();
+    }
+    stop() {
+        if (this.stopPromise)
+            return this.stopPromise;
+        const operation = this.performStop();
+        this.stopPromise = operation.finally(() => {
+            this.stopPromise = null;
+        });
+        return this.stopPromise;
+    }
+    async performStop() {
         const child = this.process;
+        const startupInProgress = this.state.state === 'loading' && !this.state.ready;
         this.stopMpvPolling();
         this.rejectPendingAirPlayReady(new Error('AirPlay playback stopped.'));
         this.rejectPendingAirPlayRetune(new Error('AirPlay playback stopped.'));
-        if (this.backend === 'mpv') {
+        if (this.backend === 'mpv' && !startupInProgress) {
             await this.sendMpv({ command: ['quit'] }).catch(() => undefined);
         }
         else if (this.backend === 'airplay') {

package/dist/providers/provider-manager.js

@@ -16,6 +16,11 @@ export class ProviderManager {
     byCountry(countryCode, limit, offset) {
         return this.radioBrowser.byCountry(countryCode, limit, offset);
     }
+    byId(provider, id) {
+        if (provider !== 'radio-browser')
+            return Promise.resolve(null);
+        return this.radioBrowser.byId(id);
+    }
     nearby(location, limit) {
         return this.radioBrowser.nearby(location, limit);
     }

package/dist/providers/radio-browser.js

@@ -47,10 +47,15 @@ const locationSchema = z
     .passthrough();
 const geoAtlasLimit = 100_000;
 const geoAtlasMaxAgeMs = 6 * 60 * 60 * 1000;
-const geoAtlasTimeoutMs = 20_000;
+// The atlas is much larger than ordinary directory responses. A single shared
+// 20-second deadline used to give each of four mirrors roughly five seconds to
+// connect, download, and parse up to 100k rows. Use a size-aware per-attempt
+// budget while retaining an overall bound and stale-cache fallback.
+const geoAtlasAttemptTimeoutMs = 30_000;
+const geoAtlasTotalTimeoutMs = 75_000;
 class ProviderUnavailableError extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, cause) {
+        super(message, cause ? { cause } : undefined);
         this.name = 'ProviderUnavailableError';
     }
 }
@@ -110,6 +115,10 @@ export class RadioBrowserProvider {
         }, { maxAgeMs: 30 * 60 * 1000 });
         return this.normalizeStations(rows);
     }
+    async byId(id) {
+        const rows = await this.request(`/json/stations/byuuid/${encodeURIComponent(id)}`, {}, { maxAgeMs: 10 * 60 * 1000 });
+        return this.normalizeStations(rows)[0] ?? null;
+    }
     async search(query, options = {}) {
         const trimmed = query.trim();
         if (!trimmed) {
@@ -289,7 +298,11 @@ export class RadioBrowserProvider {
             has_geo_info: 'true',
             limit: String(geoAtlasLimit),
             order: 'name'
-        }, { maxAgeMs: geoAtlasMaxAgeMs, timeoutMs: geoAtlasTimeoutMs });
+        }, {
+            maxAgeMs: geoAtlasMaxAgeMs,
+            timeoutMs: geoAtlasTotalTimeoutMs,
+            attemptTimeoutMs: geoAtlasAttemptTimeoutMs
+        });
         return dedupeStations(this.normalizeStations(rows)).filter(hasValidCoordinates);
     }
     async request(path, params = {}, options = {}) {
@@ -316,7 +329,8 @@ export class RadioBrowserProvider {
             }
             try {
                 const mirrorsLeft = mirrors.length - mirrorIndex;
-                const attemptTimeoutMs = Math.max(1, Math.floor(remainingMs / mirrorsLeft));
+                const fairShareTimeoutMs = Math.max(1, Math.floor(remainingMs / mirrorsLeft));
+                const attemptTimeoutMs = Math.max(1, Math.min(remainingMs, options.attemptTimeoutMs ?? fairShareTimeoutMs));
                 const value = await fetchJsonWithTimeout(url, attemptTimeoutMs);
                 this.activeBaseUrl = baseUrl;
                 if (options.maxAgeMs) {
@@ -338,8 +352,24 @@ export class RadioBrowserProvider {
         if (stale) {
             return stale;
         }
-        throw new ProviderUnavailableError(lastError?.message ?? `${this.label} request failed.`);
+        throw new ProviderUnavailableError(`${this.label} unavailable: ${describeRequestError(lastError)}`, lastError ?? undefined);
+    }
+}
+function describeRequestError(error) {
+    if (!error)
+        return 'request failed';
+    const cause = error.cause;
+    if (cause && typeof cause === 'object') {
+        const code = 'code' in cause && typeof cause.code === 'string' ? cause.code : null;
+        const message = 'message' in cause && typeof cause.message === 'string' ? cause.message : null;
+        if (code && message)
+            return `${error.message} (${code}: ${message})`;
+        if (code)
+            return `${error.message} (${code})`;
+        if (message && message !== error.message)
+            return `${error.message} (${message})`;
     }
+    return error.message || 'request failed';
 }
 function defaultRadioBrowserMirrors() {
     return [