@ciphore/radiocli 0.2.3 → 0.2.4

package/dist/providers/radio-browser.js

@@ -1,7 +1,9 @@
+import { resolveSrv } from 'node:dns/promises';
 import { z } from 'zod';
 import { ProviderCache } from './cache.js';
 import { userAgent } from '../version.js';
 import { safeExternalHttpUrl, safeMediaTarget, sanitizeTerminalText } from '../safety.js';
+import { allowsDirectDnsFallback, fetchHttpsWithSystemResolver, networkPolicy, withExternalResponse } from '../platform/network.js';
 const stationSchema = z.object({
     stationuuid: z.string(),
     name: z.string().default('Untitled station'),
@@ -47,12 +49,16 @@ const locationSchema = z
     .passthrough();
 const geoAtlasLimit = 100_000;
 const geoAtlasMaxAgeMs = 6 * 60 * 60 * 1000;
-// 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.
+// The atlas is much larger than ordinary directory responses. Give each live,
+// discovered server enough time to connect, download, and parse up to 100k rows
+// while retaining an overall bound and stale-cache fallback.
 const geoAtlasAttemptTimeoutMs = 30_000;
 const geoAtlasTotalTimeoutMs = 75_000;
+const mirrorDiscoveryTimeoutMs = 750;
+const radioBrowserService = '_api._tcp.radio-browser.info';
+const radioBrowserApiSuffix = '.api.radio-browser.info';
+const nameResolutionErrorCodes = new Set(['EAI_AGAIN', 'ENOTFOUND', 'ESERVFAIL', 'ETIMEOUT', 'EREFUSED']);
+const defaultRuntime = {};
 class ProviderUnavailableError extends Error {
     constructor(message, cause) {
         super(message, cause ? { cause } : undefined);
@@ -64,15 +70,20 @@ export function isProviderUnavailableError(error) {
 }
 export class RadioBrowserProvider {
     cache;
+    runtime;
     id = 'radio-browser';
     label = 'Radio Browser';
     baseUrls;
+    discoverMirrors;
     activeBaseUrl;
     geoAtlasPromise = null;
     geoAtlasLoadedAt = 0;
-    constructor(baseUrls = defaultRadioBrowserMirrors(), cache = new ProviderCache()) {
+    mirrorDiscoveryPromise = null;
+    constructor(baseUrls = undefined, cache = new ProviderCache(), runtime = defaultRuntime) {
         this.cache = cache;
-        this.baseUrls = baseUrls.map(url => url.replace(/\/$/, ''));
+        this.runtime = runtime;
+        this.discoverMirrors = baseUrls === undefined;
+        this.baseUrls = (baseUrls ?? defaultRadioBrowserMirrors()).map(url => url.replace(/\/$/, ''));
         this.activeBaseUrl = this.baseUrls[0] ?? 'https://all.api.radio-browser.info';
     }
     async health() {
@@ -217,36 +228,30 @@ export class RadioBrowserProvider {
         }
     }
     async detectLocation() {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 5000);
         try {
-            const response = await fetch('https://ipapi.co/json/', {
-                signal: controller.signal,
-                headers: { 'User-Agent': userAgent() }
+            return await withExternalResponse('https://ipapi.co/json/', {
+                timeoutMs: 5000,
+                init: { headers: { 'User-Agent': userAgent() } }
+            }, async (response) => {
+                if (!response.ok)
+                    return null;
+                const parsed = locationSchema.parse(await response.json());
+                if (typeof parsed.latitude !== 'number' || typeof parsed.longitude !== 'number')
+                    return null;
+                return {
+                    city: parsed.city,
+                    region: parsed.region,
+                    country: parsed.country_name,
+                    countryCode: parsed.country_code,
+                    latitude: parsed.latitude,
+                    longitude: parsed.longitude,
+                    source: 'ipapi.co'
+                };
             });
-            if (!response.ok) {
-                return null;
-            }
-            const parsed = locationSchema.parse(await response.json());
-            if (typeof parsed.latitude !== 'number' || typeof parsed.longitude !== 'number') {
-                return null;
-            }
-            return {
-                city: parsed.city,
-                region: parsed.region,
-                country: parsed.country_name,
-                countryCode: parsed.country_code,
-                latitude: parsed.latitude,
-                longitude: parsed.longitude,
-                source: 'ipapi.co'
-            };
         }
         catch {
             return null;
         }
-        finally {
-            clearTimeout(timeout);
-        }
     }
     normalizeStations(rows) {
         return rows
@@ -301,7 +306,8 @@ export class RadioBrowserProvider {
         }, {
             maxAgeMs: geoAtlasMaxAgeMs,
             timeoutMs: geoAtlasTotalTimeoutMs,
-            attemptTimeoutMs: geoAtlasAttemptTimeoutMs
+            attemptTimeoutMs: geoAtlasAttemptTimeoutMs,
+            cacheOnly: networkPolicy().lowBandwidth
         });
         return dedupeStations(this.normalizeStations(rows)).filter(hasValidCoordinates);
     }
@@ -313,10 +319,20 @@ export class RadioBrowserProvider {
                 return cached;
             }
         }
+        const policy = networkPolicy();
+        if (policy.offline || options.cacheOnly) {
+            const stale = options.maxAgeMs ? this.cache.getStale(cacheKey) : null;
+            if (stale !== null)
+                return stale;
+            throw new ProviderUnavailableError(policy.offline
+                ? `${this.label} is offline: no cached response is available.`
+                : `${this.label} is in low-bandwidth mode: no cached atlas is available. Disable RADIOCLI_LOW_BANDWIDTH to download it.`);
+        }
         let lastError = null;
-        const mirrors = preferActiveMirror(this.baseUrls, this.activeBaseUrl);
         const totalTimeoutMs = options.timeoutMs ?? 9000;
         const deadline = Date.now() + totalTimeoutMs;
+        const mirrors = preferActiveMirror(this.baseUrls, this.activeBaseUrl);
+        let discoveryAttempted = !this.discoverMirrors;
         for (let mirrorIndex = 0; mirrorIndex < mirrors.length; mirrorIndex += 1) {
             const baseUrl = mirrors[mirrorIndex];
             const remainingMs = deadline - Date.now();
@@ -328,10 +344,10 @@ export class RadioBrowserProvider {
                 url.searchParams.set(key, value);
             }
             try {
-                const mirrorsLeft = mirrors.length - mirrorIndex;
+                const mirrorsLeft = mirrors.length - mirrorIndex + (discoveryAttempted ? 0 : 1);
                 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);
+                const value = await fetchJsonWithTimeout(url, attemptTimeoutMs, this.runtime);
                 this.activeBaseUrl = baseUrl;
                 if (options.maxAgeMs) {
                     try {
@@ -347,6 +363,15 @@ export class RadioBrowserProvider {
             catch (error) {
                 lastError = error instanceof Error ? error : new Error(String(error));
             }
+            if (!discoveryAttempted && mirrorIndex === mirrors.length - 1) {
+                discoveryAttempted = true;
+                const discoveryBudgetMs = Math.min(mirrorDiscoveryTimeoutMs, Math.max(1, deadline - Date.now()));
+                const discovered = await this.loadDiscoveredMirrors(discoveryBudgetMs);
+                for (const baseUrl of discovered) {
+                    if (!mirrors.includes(baseUrl))
+                        mirrors.push(baseUrl);
+                }
+            }
         }
         const stale = this.cache.getStale(cacheKey);
         if (stale) {
@@ -354,10 +379,25 @@ export class RadioBrowserProvider {
         }
         throw new ProviderUnavailableError(`${this.label} unavailable: ${describeRequestError(lastError)}`, lastError ?? undefined);
     }
+    async loadDiscoveredMirrors(timeoutMs) {
+        const discovery = this.mirrorDiscoveryPromise ?? settleWithin(discoverRadioBrowserMirrors(this.runtime), timeoutMs, []);
+        this.mirrorDiscoveryPromise = discovery;
+        const mirrors = await discovery;
+        // Empty discovery commonly means a temporary DNS failure or timeout. Do
+        // not poison this provider instance for the remainder of the process.
+        if (mirrors.length === 0 && this.mirrorDiscoveryPromise === discovery)
+            this.mirrorDiscoveryPromise = null;
+        return mirrors;
+    }
 }
 function describeRequestError(error) {
     if (!error)
         return 'request failed';
+    const nestedCode = findErrorCode(error);
+    if (nestedCode === 'EAI_AGAIN')
+        return 'temporary DNS lookup failed (EAI_AGAIN)';
+    if (nestedCode && nameResolutionErrorCodes.has(nestedCode))
+        return `DNS lookup failed (${nestedCode})`;
     const cause = error.cause;
     if (cause && typeof cause === 'object') {
         const code = 'code' in cause && typeof cause.code === 'string' ? cause.code : null;
@@ -372,12 +412,7 @@ function describeRequestError(error) {
     return error.message || 'request failed';
 }
 function defaultRadioBrowserMirrors() {
-    return [
-        'https://all.api.radio-browser.info',
-        'https://de1.api.radio-browser.info',
-        'https://nl1.api.radio-browser.info',
-        'https://at1.api.radio-browser.info'
-    ];
+    return ['https://all.api.radio-browser.info'];
 }
 function preferActiveMirror(baseUrls, active) {
     return [active, ...baseUrls.filter(url => url !== active)];
@@ -386,27 +421,90 @@ function buildCacheKey(path, params) {
     const pairs = Object.entries(params).sort(([a], [b]) => a.localeCompare(b));
     return `${path}?${new URLSearchParams(pairs).toString()}`;
 }
-async function fetchJsonWithTimeout(url, timeoutMs) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        const response = await fetch(url, {
-            signal: controller.signal,
-            headers: {
-                'User-Agent': userAgent(' (+https://radio-browser.info)'),
-                Accept: 'application/json'
-            }
-        });
+async function fetchJsonWithTimeout(url, timeoutMs, runtime) {
+    const startedAt = Date.now();
+    const init = {
+        headers: {
+            'User-Agent': userAgent(' (+https://radio-browser.info)'),
+            Accept: 'application/json'
+        }
+    };
+    const consume = async (response) => {
         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());
+    };
+    try {
+        return await withExternalResponse(url, { timeoutMs, init }, consume);
     }
-    finally {
-        clearTimeout(timeout);
+    catch (error) {
+        const remainingMs = timeoutMs - (Date.now() - startedAt);
+        if (remainingMs <= 0 ||
+            !isNameResolutionError(error) ||
+            !isRadioBrowserApiHostname(url.hostname) ||
+            !(runtime.allowsDirectDnsFallback ?? (target => allowsDirectDnsFallback(process.env, target)))(url)) {
+            throw error;
+        }
+        return withExternalResponse(url, {
+            timeoutMs: remainingMs,
+            init,
+            fetchImpl: runtime.fetchWithSystemResolver ?? fetchHttpsWithSystemResolver
+        }, consume);
     }
 }
+async function discoverRadioBrowserMirrors(runtime) {
+    const records = await (runtime.resolveSrv ?? resolveSrv)(radioBrowserService);
+    return dedupeUrls(records
+        .filter(record => record.port === 443)
+        .sort((a, b) => a.priority - b.priority || b.weight - a.weight || a.name.localeCompare(b.name))
+        .flatMap(record => {
+        const hostname = record.name.replace(/\.$/, '').toLowerCase();
+        return isRadioBrowserApiHostname(hostname) ? [`https://${hostname}`] : [];
+    }));
+}
+function isRadioBrowserApiHostname(hostname) {
+    const normalized = hostname.toLowerCase();
+    return normalized === 'api.radio-browser.info' || normalized.endsWith(radioBrowserApiSuffix);
+}
+function isNameResolutionError(error) {
+    const code = findErrorCode(error);
+    return code !== null && nameResolutionErrorCodes.has(code);
+}
+function findErrorCode(error) {
+    const seen = new Set();
+    const pending = [error];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (!value || seen.has(value))
+            continue;
+        seen.add(value);
+        if (typeof value === 'object') {
+            if ('code' in value && typeof value.code === 'string')
+                return value.code;
+            if ('cause' in value)
+                pending.push(value.cause);
+            if (value instanceof AggregateError)
+                pending.push(...value.errors);
+        }
+    }
+    return null;
+}
+function dedupeUrls(urls) {
+    return [...new Set(urls)];
+}
+function settleWithin(promise, timeoutMs, fallback) {
+    return new Promise(resolve => {
+        const timeout = setTimeout(() => resolve(fallback), timeoutMs);
+        promise.then(value => {
+            clearTimeout(timeout);
+            resolve(value);
+        }, () => {
+            clearTimeout(timeout);
+            resolve(fallback);
+        });
+    });
+}
 export function dedupeStations(stations) {
     const seen = new Set();
     const deduped = [];

package/dist/providers/radio-garden.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { withExternalResponse } from '../platform/network.js';
 const searchSchema = z
     .object({
     hits: z
@@ -27,13 +28,14 @@ export class RadioGardenProvider {
     }
     async health() {
         try {
-            const response = await fetchWithTimeout(`${this.baseUrl}/geo`, 5000, {
-                headers: { 'User-Agent': 'radiocli/0.1' }
+            return await withExternalResponse(`${this.baseUrl}/geo`, {
+                timeoutMs: 5000,
+                init: { headers: { 'User-Agent': 'radiocli/0.1' } }
+            }, response => {
+                if (response.status === 403)
+                    return 'blocked by edge protection';
+                return response.ok ? 'online' : `${response.status} ${response.statusText}`;
             });
-            if (response.status === 403) {
-                return 'blocked by edge protection';
-            }
-            return response.ok ? 'online' : `${response.status} ${response.statusText}`;
         }
         catch (error) {
             return error instanceof Error ? error.message : 'unavailable';
@@ -42,13 +44,14 @@ export class RadioGardenProvider {
     async search(query, options = {}) {
         const url = new URL(`${this.baseUrl}/search`);
         url.searchParams.set('q', query);
-        const response = await fetchWithTimeout(url, 9000, {
-            headers: { 'User-Agent': 'radiocli/0.1', Accept: 'application/json' }
+        const parsed = await withExternalResponse(url, {
+            timeoutMs: 9000,
+            init: { headers: { 'User-Agent': 'radiocli/0.1', Accept: 'application/json' } }
+        }, async (response) => {
+            if (!response.ok)
+                throw new Error(`${this.label} search failed: ${response.status} ${response.statusText}`);
+            return searchSchema.parse(await response.json());
         });
-        if (!response.ok) {
-            throw new Error(`${this.label} search failed: ${response.status} ${response.statusText}`);
-        }
-        const parsed = searchSchema.parse(await response.json());
         return (parsed.hits ?? [])
             .map(hit => hit._source)
             .filter((source) => source?.type === 'channel' && Boolean(source.url))
@@ -75,13 +78,3 @@ export class RadioGardenProvider {
         };
     }
 }
-async function fetchWithTimeout(url, timeoutMs, init = {}) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(url, { ...init, signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}