@ciphore/radiocli 0.2.0 → 0.2.1

package/dist/providers/radio-browser.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ProviderCache } from './cache.js';
 import { userAgent } from '../version.js';
+import { safeExternalHttpUrl, safeMediaTarget, sanitizeTerminalText } from '../safety.js';
 const stationSchema = z.object({
     stationuuid: z.string(),
     name: z.string().default('Untitled station'),
@@ -47,6 +48,15 @@ const locationSchema = z
 const geoAtlasLimit = 100_000;
 const geoAtlasMaxAgeMs = 6 * 60 * 60 * 1000;
 const geoAtlasTimeoutMs = 20_000;
+class ProviderUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ProviderUnavailableError';
+    }
+}
+export function isProviderUnavailableError(error) {
+    return error instanceof ProviderUnavailableError;
+}
 export class RadioBrowserProvider {
     cache;
     id = 'radio-browser';
@@ -66,9 +76,11 @@ export class RadioBrowserProvider {
     }
     async countries(limit = 240) {
         const rows = await this.request('/json/countries', { hidebroken: 'true' }, { maxAgeMs: 24 * 60 * 60 * 1000 });
-        return z
-            .array(countrySchema)
-            .parse(rows)
+        return rows
+            .flatMap(row => {
+            const parsed = countrySchema.safeParse(row);
+            return parsed.success ? [parsed.data] : [];
+        })
             .map(row => ({
             name: row.name,
             code: row.iso_3166_1.toUpperCase(),
@@ -104,68 +116,81 @@ export class RadioBrowserProvider {
             return this.popular(options.limit ?? 80);
         }
         const limit = options.limit ?? 60;
+        const offset = Math.max(0, options.offset ?? 0);
         const baseParams = {
             hidebroken: 'true',
-            limit: String(limit),
-            offset: String(Math.max(0, options.offset ?? 0)),
+            // Build a stable merged result set before slicing the requested page;
+            // using the merged count as four independent provider offsets skips data.
+            limit: String(limit + offset),
+            offset: '0',
             order: 'clickcount',
             reverse: 'true',
             ...(options.codec ? { codec: options.codec } : {}),
             ...(options.language ? { language: options.language } : {}),
             ...(options.countryCode ? { countrycode: options.countryCode.toUpperCase() } : {})
         };
-        const variants = await Promise.allSettled([
+        const primary = await Promise.allSettled([
             this.request('/json/stations/search', { ...baseParams, name: trimmed }, { maxAgeMs: 10 * 60 * 1000 }),
-            this.request('/json/stations/search', { ...baseParams, tag: trimmed }, { maxAgeMs: 10 * 60 * 1000 }),
-            this.request('/json/stations/search', { ...baseParams, country: trimmed }, { maxAgeMs: 10 * 60 * 1000 }),
-            this.request('/json/stations/search', { ...baseParams, language: trimmed }, { maxAgeMs: 10 * 60 * 1000 })
+            this.request('/json/stations/search', { ...baseParams, tag: trimmed }, { maxAgeMs: 10 * 60 * 1000 })
         ]);
-        let rows = variants.flatMap(result => (result.status === 'fulfilled' ? result.value : []));
-        const failures = variants.filter(result => result.status === 'rejected');
-        if (failures.length === variants.length) {
-            const firstError = failures[0]?.reason;
-            const message = firstError instanceof Error ? firstError.message : String(firstError ?? 'all search requests failed');
-            throw new Error(`${this.label} search failed: ${message}`);
+        let attempts = [...primary];
+        let rows = fulfilledRows(primary);
+        if (rows.length < Math.min(12, limit + offset)) {
+            const secondary = await Promise.allSettled([
+                this.request('/json/stations/search', { ...baseParams, country: trimmed }, { maxAgeMs: 10 * 60 * 1000 }),
+                this.request('/json/stations/search', { ...baseParams, language: trimmed }, { maxAgeMs: 10 * 60 * 1000 })
+            ]);
+            attempts = [...attempts, ...secondary];
+            rows.push(...fulfilledRows(secondary));
         }
         const tokens = trimmed.split(/\s+/).filter(token => token.length > 2).slice(0, 4);
         if (rows.length === 0 && tokens.length > 1) {
-            const tokenResults = await Promise.allSettled(tokens.flatMap(token => [
+            const tokenResults = await Promise.allSettled(tokens.slice(0, 3).flatMap(token => [
                 this.request('/json/stations/search', { ...baseParams, name: token, limit: '25' }, { maxAgeMs: 10 * 60 * 1000 }),
-                this.request('/json/stations/search', { ...baseParams, tag: token, limit: '25' }, { maxAgeMs: 10 * 60 * 1000 }),
-                this.request('/json/stations/search', { ...baseParams, country: token, limit: '25' }, { maxAgeMs: 10 * 60 * 1000 }),
-                this.request('/json/stations/search', { ...baseParams, language: token, limit: '25' }, { maxAgeMs: 10 * 60 * 1000 })
+                this.request('/json/stations/search', { ...baseParams, tag: token, limit: '25' }, { maxAgeMs: 10 * 60 * 1000 })
             ]));
-            rows = tokenResults.flatMap(result => (result.status === 'fulfilled' ? result.value : []));
+            attempts.push(...tokenResults);
+            rows = fulfilledRows(tokenResults);
+        }
+        if (attempts.every(result => result.status === 'rejected')) {
+            const firstError = attempts[0]?.status === 'rejected' ? attempts[0].reason : 'all search requests failed';
+            const message = firstError instanceof Error ? firstError.message : String(firstError);
+            throw new Error(`${this.label} search failed: ${message}`);
         }
         return filterStations(dedupeStations(this.normalizeStations(rows)), options)
             .sort((a, b) => scoreStation(b, trimmed, tokens) - scoreStation(a, trimmed, tokens))
-            .slice(0, limit);
+            .slice(offset, offset + limit);
     }
     async nearby(location, limit = 80) {
         const stations = await this.geotaggedAtlas();
-        return stations
-            .map(station => ({
-            ...station,
-            distanceKm: haversineKm(location.latitude, location.longitude, station.latitude, station.longitude)
-        }))
-            .sort(compareNearbyStations)
-            .slice(0, limit);
+        return nearestStations(stations, location, limit);
     }
     async resolve(station) {
         if (station.provider !== this.id) {
-            if (!station.streamUrl) {
+            const streamUrl = station.streamUrl ? safeMediaTarget(station.streamUrl) : null;
+            if (!streamUrl) {
                 throw new Error(`Station ${station.name} does not expose a stream URL.`);
             }
-            return { url: station.streamUrl, name: station.name };
+            return { url: streamUrl, name: station.name };
         }
-        const result = clickResolveSchema.parse(await this.request(`/json/url/${encodeURIComponent(station.id)}`, {}, { maxAgeMs: 24 * 60 * 60 * 1000 }));
-        if (!result.ok || !result.url) {
-            if (station.streamUrl) {
-                return { url: station.streamUrl, name: station.name };
+        try {
+            // Click URLs can rotate and the endpoint records directory engagement, so
+            // do not reuse a day-old resolution from the general provider cache.
+            const result = clickResolveSchema.parse(await this.request(`/json/url/${encodeURIComponent(station.id)}`, {}, { timeoutMs: 6000 }));
+            const resolvedUrl = result.url ? safeMediaTarget(result.url) : null;
+            if (result.ok && resolvedUrl) {
+                return { url: resolvedUrl, name: sanitizeTerminalText(result.name) ?? station.name };
             }
-            throw new Error(result.message ?? `Radio Browser could not resolve ${station.name}.`);
         }
-        return { url: result.url, name: result.name };
+        catch {
+            // A directory outage should not discard a validated URL already supplied
+            // with the station row.
+        }
+        const fallbackUrl = station.streamUrl ? safeMediaTarget(station.streamUrl) : null;
+        if (fallbackUrl) {
+            return { url: fallbackUrl, name: station.name };
+        }
+        throw new Error(`Radio Browser could not resolve ${station.name}.`);
     }
     // Give back to the directory: an upvote on favorite helps surface good
     // stations for everyone. Radio Browser rate-limits votes per IP, so this is
@@ -215,9 +240,11 @@ export class RadioBrowserProvider {
         }
     }
     normalizeStations(rows) {
-        return z
-            .array(stationSchema)
-            .parse(rows)
+        return rows
+            .flatMap(row => {
+            const parsed = stationSchema.safeParse(row);
+            return parsed.success ? [parsed.data] : [];
+        })
             .map(row => ({
             id: row.stationuuid,
             provider: this.id,
@@ -230,9 +257,9 @@ export class RadioBrowserProvider {
             tags: splitCsv(row.tags ?? undefined).slice(0, 8),
             codec: cleanText(row.codec ?? undefined),
             bitrate: row.bitrate ?? undefined,
-            homepage: cleanText(row.homepage ?? undefined),
-            favicon: cleanText(row.favicon ?? undefined),
-            streamUrl: cleanText(row.url_resolved ?? row.url ?? undefined),
+            homepage: safeOptionalExternalUrl(row.homepage),
+            favicon: safeOptionalExternalUrl(row.favicon),
+            streamUrl: safeOptionalMediaTarget(row.url_resolved ?? row.url),
             votes: row.votes ?? undefined,
             clickCount: row.clickcount ?? undefined,
             latitude: row.geo_lat ?? undefined,
@@ -274,20 +301,32 @@ export class RadioBrowserProvider {
             }
         }
         let lastError = null;
-        for (const baseUrl of preferActiveMirror(this.baseUrls, this.activeBaseUrl)) {
+        const mirrors = preferActiveMirror(this.baseUrls, this.activeBaseUrl);
+        const totalTimeoutMs = options.timeoutMs ?? 9000;
+        const deadline = Date.now() + totalTimeoutMs;
+        for (let mirrorIndex = 0; mirrorIndex < mirrors.length; mirrorIndex += 1) {
+            const baseUrl = mirrors[mirrorIndex];
+            const remainingMs = deadline - Date.now();
+            if (remainingMs <= 0) {
+                break;
+            }
             const url = new URL(`${baseUrl}${path}`);
             for (const [key, value] of Object.entries(params)) {
                 url.searchParams.set(key, value);
             }
             try {
-                const response = await fetchWithTimeout(url, options.timeoutMs ?? 9000);
-                if (!response.ok) {
-                    throw new Error(`${this.label} request failed: ${response.status} ${response.statusText}`);
-                }
-                const value = (await response.json());
+                const mirrorsLeft = mirrors.length - mirrorIndex;
+                const attemptTimeoutMs = Math.max(1, Math.floor(remainingMs / mirrorsLeft));
+                const value = await fetchJsonWithTimeout(url, attemptTimeoutMs);
                 this.activeBaseUrl = baseUrl;
                 if (options.maxAgeMs) {
-                    this.cache.set(cacheKey, value);
+                    try {
+                        this.cache.set(cacheKey, value);
+                    }
+                    catch {
+                        // A read-only or full cache directory must not turn live data into
+                        // an apparent provider outage.
+                    }
                 }
                 return value;
             }
@@ -299,7 +338,7 @@ export class RadioBrowserProvider {
         if (stale) {
             return stale;
         }
-        throw lastError ?? new Error(`${this.label} request failed.`);
+        throw new ProviderUnavailableError(lastError?.message ?? `${this.label} request failed.`);
     }
 }
 function defaultRadioBrowserMirrors() {
@@ -317,17 +356,22 @@ function buildCacheKey(path, params) {
     const pairs = Object.entries(params).sort(([a], [b]) => a.localeCompare(b));
     return `${path}?${new URLSearchParams(pairs).toString()}`;
 }
-async function fetchWithTimeout(url, timeoutMs) {
+async function fetchJsonWithTimeout(url, timeoutMs) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        return await fetch(url, {
+        const response = await fetch(url, {
             signal: controller.signal,
             headers: {
                 'User-Agent': userAgent(' (+https://radio-browser.info)'),
                 Accept: 'application/json'
             }
         });
+        if (!response.ok) {
+            throw new Error(`Radio Browser request failed: ${response.status} ${response.statusText}`);
+        }
+        // Keep the abort timer alive while consuming the body as well as headers.
+        return (await response.json());
     }
     finally {
         clearTimeout(timeout);
@@ -356,8 +400,15 @@ function splitCsv(value) {
         .filter((part) => Boolean(part));
 }
 function cleanText(value) {
-    const cleaned = value?.replace(/\s+/g, ' ').trim();
-    return cleaned ? cleaned : undefined;
+    return sanitizeTerminalText(value);
+}
+function safeOptionalExternalUrl(value) {
+    const cleaned = cleanText(value);
+    return cleaned ? safeExternalHttpUrl(cleaned) ?? undefined : undefined;
+}
+function safeOptionalMediaTarget(value) {
+    const cleaned = cleanText(value);
+    return cleaned ? safeMediaTarget(cleaned) ?? undefined : undefined;
 }
 function hasValidCoordinates(station) {
     return (typeof station.latitude === 'number' &&
@@ -378,6 +429,35 @@ function compareNearbyStations(a, b) {
     }
     return a.name.localeCompare(b.name);
 }
+function nearestStations(stations, location, limit) {
+    const nearest = [];
+    const boundedLimit = Math.max(0, Math.floor(limit));
+    if (boundedLimit === 0)
+        return nearest;
+    for (const station of stations) {
+        if (!hasValidCoordinates(station))
+            continue;
+        const candidate = {
+            ...station,
+            distanceKm: haversineKm(location.latitude, location.longitude, station.latitude, station.longitude)
+        };
+        let low = 0;
+        let high = nearest.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (compareNearbyStations(nearest[middle], candidate) <= 0)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        if (low < boundedLimit) {
+            nearest.splice(low, 0, candidate);
+            if (nearest.length > boundedLimit)
+                nearest.pop();
+        }
+    }
+    return nearest;
+}
 function nearbyQualityScore(station) {
     return ((station.lastCheckedOk ? 100 : 0) +
         Math.log10((station.clickCount ?? 0) + 1) * 12 +
@@ -395,6 +475,9 @@ function haversineKm(lat1, lon1, lat2, lon2) {
 function toRad(value) {
     return (value * Math.PI) / 180;
 }
+function fulfilledRows(results) {
+    return results.flatMap(result => result.status === 'fulfilled' ? result.value : []);
+}
 function scoreStation(station, query, tokens) {
     const searchable = [
         station.name,
@@ -417,12 +500,11 @@ function filterStations(stations, options) {
         if (options.minBitrate && (station.bitrate ?? 0) < options.minBitrate) {
             return false;
         }
-        if (options.codec && station.codec && station.codec.toLowerCase() !== options.codec.toLowerCase()) {
+        if (options.codec && (!station.codec || station.codec.toLowerCase() !== options.codec.toLowerCase())) {
             return false;
         }
         if (options.language &&
-            station.language &&
-            !station.language.toLowerCase().includes(options.language.toLowerCase())) {
+            (!station.language || !station.language.toLowerCase().includes(options.language.toLowerCase()))) {
             return false;
         }
         return true;

package/dist/safety.js

@@ -0,0 +1,44 @@
+import { isAbsolute } from 'node:path';
+// C0/C1 controls, DEL, ANSI CSI/OSC sequences, and bidi overrides can alter a
+// terminal outside the text's visible cells. Preserve ordinary Unicode.
+const terminalEscapePattern = /\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007]*(?:\u0007|\u001b\\)?)/g;
+const unsafeControlPattern = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/g;
+const bidiControlPattern = /[\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
+export function sanitizeTerminalText(value) {
+    const cleaned = value
+        ?.replace(terminalEscapePattern, '')
+        .replace(unsafeControlPattern, '')
+        .replace(bidiControlPattern, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return cleaned || undefined;
+}
+export function safeExternalHttpUrl(value) {
+    try {
+        const cleaned = value.trim();
+        const parsed = new URL(cleaned);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:' ? cleaned : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Accept public HTTP(S) streams and explicit local playlist targets. */
+export function safeMediaTarget(value) {
+    const target = value.trim();
+    if (!target || target.startsWith('-')) {
+        return null;
+    }
+    if (isAbsolute(target)) {
+        return target;
+    }
+    try {
+        const parsed = new URL(target);
+        return parsed.protocol === 'http:' || parsed.protocol === 'https:' || parsed.protocol === 'file:'
+            ? target
+            : null;
+    }
+    catch {
+        return null;
+    }
+}