@ciphore/radiocli 0.2.3 → 0.2.4

package/dist/ui/screens/SettingsScreen.js

@@ -10,7 +10,11 @@ import { playbackBackendCapabilities } from '../../player/backend-install.js';
 import { airPlayReceiverSettingValue } from '../airplay-settings.js';
 import { audioOutputLabel, audioOutputSettingValue } from '../audio-output.js';
 import { updateStatusText } from '../../update-check.js';
-export function SettingsScreen({ page = 'root', selected, settings, appVersion, updateCheck, storePath, playback, backends, airPlayDevices, providerHealth, theme, diagnostics, width, height }) {
+import { useDisplay } from '../display-context.js';
+import { toAsciiSafe } from '../ascii.js';
+export function SettingsScreen({ page = 'root', selected, settings, appVersion, updateCheck, storePath, playback, backends, airPlayDevices, providerHealth, theme, diagnostics, width, height, airPlaySupported = true }) {
+    const { ascii } = useDisplay();
+    const a = (value) => ascii ? toAsciiSafe(value) : value;
     const accent = themeAccent(theme);
     const lineWidth = Math.max(32, width - 4);
     const group = settingsGroup(page);
@@ -33,12 +37,12 @@ export function SettingsScreen({ page = 'root', selected, settings, appVersion,
     const labelWidth = Math.min(34, Math.max(20, lineWidth - valueGap - 24));
     const valueWidth = Math.max(12, Math.min(34, lineWidth - labelWidth - valueGap - 2));
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "Settings", subtitle: group ? `Settings › ${group.label}` : 'Choose a category', width: width, theme: theme }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Menu, { items: menuWindow.items, selected: menuWindow.selectedOffset, keyFor: item => item, render: (item, _index, active) => {
-                        const label = settingLabel(item, updateCheck, appVersion);
+                        const label = settingLabel(item, updateCheck, appVersion, airPlaySupported);
                         const value = page === 'root'
                             ? settingsRootValue(item)
                             : settingValue(item, settings, diagnostics, backends, airPlayDevices, updateCheck, appVersion);
-                        return (_jsxs(Box, { width: lineWidth, children: [_jsx(Pointer, { active: active }), _jsx(Box, { width: labelWidth, children: _jsx(Text, { color: active ? accent : undefined, bold: active, children: truncate(label, labelWidth) }) }), _jsx(Box, { width: valueGap }), _jsx(Box, { width: valueWidth, children: _jsx(Text, { color: value ? accent : textMuted, children: truncate(value ?? '', valueWidth) }) })] }));
-                    } }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: textMuted, bold: true, children: "Selected" }), _jsx(Text, { color: textMuted, children: truncate(detail, lineWidth) })] })] }));
+                        return (_jsxs(Box, { width: lineWidth, children: [_jsx(Pointer, { active: active }), _jsx(Box, { width: labelWidth, children: _jsx(Text, { color: active ? accent : undefined, bold: active, children: a(truncate(label, labelWidth)) }) }), _jsx(Box, { width: valueGap }), _jsx(Box, { width: valueWidth, children: _jsx(Text, { color: value ? accent : textMuted, children: a(truncate(value ?? '', valueWidth)) }) })] }));
+                    } }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { color: textMuted, bold: true, children: "Selected" }), _jsx(Text, { color: textMuted, children: a(truncate(detail, lineWidth)) })] })] }));
 }
 function settingsMenuWindow(items, selected, height) {
     const reservedRows = 6;
@@ -111,13 +115,16 @@ export function settingValue(item, settings, diagnostics, backends, airPlayDevic
             return `prev ${settings.mediaKeys.previous.length} · play ${settings.mediaKeys.playPause.length} · next ${settings.mediaKeys.next.length}`;
         case 'Export preferences and library':
             return 'JSON backup';
-        case 'Import preferences and library':
+        case 'Restore preferences and library':
             return 'restore JSON backup';
         default:
             return undefined;
     }
 }
-export function settingLabel(item, updateCheck, currentVersion) {
+export function settingLabel(item, updateCheck, currentVersion, airPlaySupported = true) {
+    if (item === 'AirPlay receiver' && !airPlaySupported) {
+        return 'AirPlay receiver (macOS only)';
+    }
     if (item === 'Check for updates') {
         return updateStatusText(updateCheck, currentVersion).endsWith('available') ? 'Install update' : 'Check now';
     }
@@ -145,7 +152,7 @@ function settingDetail(input) {
     if (item === 'Automatically check for updates') {
         return 'When enabled, RadioCLI checks the registry once whenever the app launches.';
     }
-    if (item === 'Export preferences and library' || item === 'Import preferences and library') {
+    if (item === 'Export preferences and library' || item === 'Restore preferences and library') {
         return `Library file: ${truncate(storePath, Math.max(8, lineWidth - 14))}`;
     }
     if (item === 'Share favorite votes with Radio Browser') {

package/dist/ui/screens/StatsScreen.js

@@ -6,6 +6,7 @@ import { panelBorder, textMuted, themeAccent, themeContributionColors } from '..
 import { panelBorderStyle, useDisplay } from '../display-context.js';
 import { ScreenHeader } from '../components/ScreenHeader.js';
 import { truncate } from '../format.js';
+import { toAsciiSafe } from '../ascii.js';
 const monthLabels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const dayLabelWidth = 5;
 // Two terminal columns are approximately one row high in common monospace
@@ -15,6 +16,7 @@ const heatmapCell = '  ';
 const heatmapGap = '';
 export function StatsScreen({ library, theme, width, height }) {
     const { panel: panelBackground, ascii } = useDisplay();
+    const a = (value) => ascii ? toAsciiSafe(value) : value;
     const stats = computeListeningStats(library.activity.sessions);
     const contentWidth = Math.max(20, width - 4);
     const graph = buildContributionGraph(stats.days, contentWidth, height);
@@ -24,7 +26,7 @@ export function StatsScreen({ library, theme, width, height }) {
     const metricWidth = Math.max(28, Math.floor((contentWidth - 2) / 2));
     const favoriteWidth = Math.max(8, metricWidth - 18);
     const compact = height < 30;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "Listening stats", subtitle: "Local listening history \u00B7 never leaves this machine", width: width, theme: theme }), _jsxs(Box, { marginTop: 1, paddingBottom: 1, borderStyle: panelBorderStyle(ascii, 'single'), borderColor: panelBorder, borderBackgroundColor: panelBackground, backgroundColor: panelBackground, width: width, flexDirection: "column", children: [_jsx(Box, { children: _jsxs(Text, { color: themeAccent(theme), bold: true, children: ["Activity \u2014 ", graph.year] }) }), _jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: textMuted, children: [' '.repeat(dayLabelWidth), graph.months] }), graph.rows.map(row => (_jsx(React.Fragment, { children: Array.from({ length: graph.tileHeight }, (_, tileLine) => (_jsxs(Box, { children: [_jsx(Text, { color: textMuted, children: tileLine === 0 ? row.label.padEnd(dayLabelWidth) : ' '.repeat(dayLabelWidth) }), renderContributionCells(row.cells, graphColors, graph.cellGap)] }, `${row.key}-${tileLine}`))) }, row.key)))] })] }), _jsxs(Box, { marginTop: 1, borderStyle: panelBorderStyle(ascii, 'single'), borderColor: panelBorder, borderBackgroundColor: panelBackground, backgroundColor: panelBackground, width: width, flexDirection: "column", children: [_jsx(Text, { color: themeAccent(theme), bold: true, children: "Summary" }), _jsxs(Box, { marginTop: compact ? 0 : 1, flexDirection: "column", width: contentWidth, children: [metricPair('Favorite station', truncate(favorite, favoriteWidth), 'Total hours listened', formatHours(totalHours), metricWidth, theme), metricPair('Sessions', stats.sessions.toLocaleString(), 'Longest streak', formatDays(stats.longestStreak), metricWidth, theme), metricPair('Current streak', formatDays(stats.currentStreak), 'Stations listened', stats.listenedStationCount.toLocaleString(), metricWidth, theme), metricPair('Active days', `${stats.activeDays}/${stats.totalTrackedDays}`, 'Stations counted after', '2 min', metricWidth, theme)] }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: textMuted, children: "Less \u00B7 " }), graphColors.map(color => (_jsxs(React.Fragment, { children: [renderLegendCell(color, graph.cellText, graph.cellGap), _jsx(Text, { children: " " })] }, color))), _jsx(Text, { color: textMuted, children: "More" })] })] })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ScreenHeader, { title: "Listening stats", subtitle: "Local listening history \u00B7 never leaves this machine", width: width, theme: theme }), _jsxs(Box, { marginTop: 1, paddingBottom: 1, borderStyle: panelBorderStyle(ascii, 'single'), borderColor: panelBorder, borderBackgroundColor: panelBackground, backgroundColor: panelBackground, width: width, flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { color: themeAccent(theme), bold: true, children: a(`Activity — ${graph.year}`) }) }), _jsxs(Box, { flexDirection: "column", "aria-label": `Activity graph: ${stats.activeDays} active days in ${graph.year}`, children: [_jsxs(Text, { color: textMuted, children: [' '.repeat(dayLabelWidth), graph.months] }), graph.rows.map(row => (_jsx(React.Fragment, { children: Array.from({ length: graph.tileHeight }, (_, tileLine) => (_jsxs(Box, { children: [_jsx(Text, { color: textMuted, children: tileLine === 0 ? row.label.padEnd(dayLabelWidth) : ' '.repeat(dayLabelWidth) }), renderContributionCells(row.cells, graphColors, graph.cellGap)] }, `${row.key}-${tileLine}`))) }, row.key)))] })] }), _jsxs(Box, { marginTop: 1, borderStyle: panelBorderStyle(ascii, 'single'), borderColor: panelBorder, borderBackgroundColor: panelBackground, backgroundColor: panelBackground, width: width, flexDirection: "column", children: [_jsx(Text, { color: themeAccent(theme), bold: true, children: "Summary" }), _jsxs(Box, { marginTop: compact ? 0 : 1, flexDirection: "column", width: contentWidth, children: [metricPair('Favorite station', a(truncate(favorite, favoriteWidth)), 'Total hours listened', formatHours(totalHours), metricWidth, theme), metricPair('Sessions', stats.sessions.toLocaleString(), 'Longest streak', formatDays(stats.longestStreak), metricWidth, theme), metricPair('Current streak', formatDays(stats.currentStreak), 'Stations listened', stats.listenedStationCount.toLocaleString(), metricWidth, theme), metricPair('Active days', `${stats.activeDays}/${stats.totalTrackedDays}`, 'Stations counted after', '2 min', metricWidth, theme)] }), _jsxs(Box, { marginTop: 1, "aria-hidden": true, children: [_jsx(Text, { color: textMuted, children: a('Less · ') }), graphColors.map(color => (_jsxs(React.Fragment, { children: [renderLegendCell(color, graph.cellText, graph.cellGap), _jsx(Text, { children: " " })] }, color))), _jsx(Text, { color: textMuted, children: "More" })] })] })] }));
 }
 function renderContributionCells(cells, graphColors, cellGap) {
     const runs = [];

package/dist/ui/system-actions.js

@@ -1,65 +1,93 @@
 import { spawn } from 'node:child_process';
-import { resolveCommand } from '../player/command.js';
+import { resolveCommand } from '../platform/executables.js';
 import { safeExternalHttpUrl } from '../safety.js';
-// The command used to open a URL in the platform's default handler.
-export function openExternalCommand(platform = process.platform) {
-    if (platform === 'darwin') {
-        return { command: 'open', args: [] };
-    }
-    if (platform === 'win32') {
-        // Direct invocation avoids cmd.exe interpreting URL query characters.
-        return { command: 'explorer', args: [] };
-    }
-    return { command: 'xdg-open', args: [] };
-}
-// Candidate clipboard tools per platform, in priority order. pbcopy/clip ship
-// with macOS/Windows; Linux/BSD rely on whichever of these is installed.
-export function clipboardCommands(platform = process.platform) {
-    if (platform === 'darwin') {
-        return [{ command: 'pbcopy', args: [] }];
-    }
-    if (platform === 'win32') {
-        return [{ command: 'clip', args: [] }];
-    }
-    return [
-        { command: 'wl-copy', args: [] },
-        { command: 'xclip', args: ['-selection', 'clipboard'] },
-        { command: 'xsel', args: ['--clipboard', '--input'] }
-    ];
-}
-export function openExternal(url, platform = process.platform) {
+import { browserCommands, clipboardCandidates, hasGraphicalSession } from '../platform/desktop.js';
+import { identifyPlatform } from '../platform/runtime.js';
+import { waitForLaunch } from '../platform/launch-command.js';
+export async function openExternal(url, platform = process.platform, deps = {}) {
     const safeUrl = safeExternalHttpUrl(url);
-    if (!safeUrl) {
+    const env = deps.env ?? process.env;
+    const host = identifyPlatform({ platform, env });
+    if (!safeUrl || !hasGraphicalSession(host, env))
         return false;
+    for (const { command, args } of browserCommands(host)) {
+        const executable = (deps.resolve ?? resolveCommand)(command);
+        if (!executable)
+            continue;
+        try {
+            // xdg-open may run for the browser's entire lifetime. Observe startup
+            // failure, then let the desktop application own its detached process.
+            const child = (deps.spawn ?? spawn)(executable, [...args, safeUrl], { stdio: 'ignore', env, detached: true, windowsHide: true });
+            await waitForLaunch(child);
+            return true;
+        }
+        catch { /* Try the next available opener after a launch failure. */ }
     }
-    const { command, args } = openExternalCommand(platform);
-    try {
-        const child = spawn(resolveCommand(command) ?? command, [...args, safeUrl], { stdio: 'ignore', detached: true });
-        child.on('error', () => undefined);
-        child.unref();
-        return true;
-    }
-    catch {
-        // Opening a browser is best-effort; never crash the TUI over it.
+    return false;
+}
+export async function copyToClipboard(text, platform = process.platform, deps = {}) {
+    const env = deps.env ?? process.env;
+    const host = identifyPlatform({ platform, env });
+    if (!hasGraphicalSession(host, env))
         return false;
+    for (const { command, args } of clipboardCandidates(host)) {
+        const executable = (deps.resolve ?? resolveCommand)(command);
+        if (executable && await runHelper(executable, args, text, deps))
+            return true;
     }
+    return false;
 }
-export function copyToClipboard(text, platform = process.platform) {
-    for (const { command, args } of clipboardCommands(platform)) {
-        const resolved = resolveCommand(command);
-        if (!resolved) {
-            continue;
-        }
+function runHelper(command, args, input, deps) {
+    return new Promise(resolve => {
+        let child;
+        let settled = false;
+        let stopping = false;
+        let forceTimer;
+        let cleanupTimer;
+        const signal = (value) => {
+            try {
+                child?.kill(value);
+            }
+            catch { /* The failed action remains false; cleanup is still bounded. */ }
+        };
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            clearTimeout(forceTimer);
+            clearTimeout(cleanupTimer);
+            resolve(ok);
+        };
+        const stop = () => {
+            if (settled || stopping)
+                return;
+            stopping = true;
+            forceTimer = setTimeout(() => signal('SIGKILL'), 250);
+            cleanupTimer = setTimeout(() => {
+                // Even an uninterruptible OS process must not keep RadioCLI alive.
+                child?.unref();
+                finish(false);
+            }, 1_000);
+            child?.stdin?.destroy();
+            signal('SIGTERM');
+        };
+        const timer = setTimeout(stop, deps.timeoutMs ?? 5000);
         try {
-            const child = spawn(resolved, args, { stdio: ['pipe', 'ignore', 'ignore'] });
-            child.on('error', () => undefined);
-            child.stdin.write(text);
-            child.stdin.end();
-            return true;
+            child = (deps.spawn ?? spawn)(command, args, { stdio: ['pipe', 'ignore', 'ignore'], env: deps.env ?? process.env, windowsHide: true });
+            child.on('error', () => { if (child?.pid)
+                stop();
+            else
+                finish(false); });
+            child.once('close', code => finish(!stopping && code === 0));
+            child.stdin?.on('error', stop);
+            child.stdin?.end(input);
         }
         catch {
-            continue;
+            if (child?.pid)
+                stop();
+            else
+                finish(false);
         }
-    }
-    return false;
+    });
 }

package/dist/ui/terminal-renderer.js

@@ -0,0 +1,16 @@
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { resolveTerminalCapabilities } from '../platform/terminal.js';
+/**
+ * Ink uses Chalk's shared instance for both text and panel fills. FORCE_COLOR
+ * is a minimum in Chalk, so setting it cannot cap a Windows/CI/truecolor host
+ * at 16 or 256 colors. Set the instance's level before the first Ink render.
+ * Resolve from Ink itself so nested dependency installations work as well.
+ */
+export async function configureTerminalRenderer(env = process.env, evidence = {}) {
+    const terminal = resolveTerminalCapabilities(env, evidence);
+    const inkRequire = createRequire(import.meta.resolve('ink'));
+    const { default: chalk } = await import(pathToFileURL(inkRequire.resolve('chalk')).href);
+    chalk.level = terminal.colorLevel;
+    return terminal;
+}

package/dist/ui/use-alarm-tui.js

@@ -180,6 +180,40 @@ export function useAlarmTui(params) {
         }
         await refreshRuntime();
     }, [refreshRuntime, service, setMessage]);
+    const deleteAlarm = useCallback(async (alarm) => {
+        let phase = 'disable';
+        let message;
+        try {
+            // Persist the safe state before touching native jobs. A failed cleanup
+            // can then be retried without another write in the error handler.
+            const disabled = store.toggleAlarm(alarm.id, false);
+            const disabledSnapshot = store.snapshot();
+            alarmStateRef.current = disabledSnapshot.alarms;
+            setLibrary(disabledSnapshot);
+            phase = 'native';
+            await service.remove(disabled);
+            phase = 'definition';
+            store.removeAlarm(alarm.id);
+            const snapshot = store.snapshot();
+            alarmStateRef.current = snapshot.alarms;
+            setLibrary(snapshot);
+            setSelected(value => clamp(value, snapshot.alarms.length + 1));
+            message = `Deleted ${alarm.label}.`;
+        }
+        catch (error) {
+            message = phase === 'disable'
+                ? `Delete canceled: ${messageOf(error)}. Alarm and native jobs unchanged.`
+                : phase === 'native'
+                    ? `Delete cleanup failed: ${messageOf(error)}. ${alarm.label} was kept disabled; press r to repair.`
+                    : `Native cleanup completed. Save failed: ${messageOf(error)}. ${alarm.label} was kept disabled; retry deletion.`;
+        }
+        finally {
+            busyAlarmIdsRef.current.delete(alarm.id);
+            setBusyAlarmIds(new Set(busyAlarmIdsRef.current));
+        }
+        await refreshRuntime();
+        setMessage(message);
+    }, [refreshRuntime, service, setLibrary, setMessage, setSelected, store]);
     const saveDraft = useCallback(() => {
         if (!draft || savingRef.current)
             return;
@@ -343,26 +377,7 @@ export function useAlarmTui(params) {
                 setDeletingId(undefined);
                 busyAlarmIdsRef.current.add(alarm.id);
                 setBusyAlarmIds(new Set(busyAlarmIdsRef.current));
-                void service.remove(alarm).then(() => {
-                    if (store.getAlarm(alarm.id))
-                        store.removeAlarm(alarm.id);
-                    const snapshot = store.snapshot();
-                    alarmStateRef.current = snapshot.alarms;
-                    setLibrary(snapshot);
-                    setSelected(value => clamp(value, snapshot.alarms.length + 1));
-                    setMessage(`Deleted ${alarm.label}.`);
-                }).catch(error => {
-                    const existing = store.getAlarm(alarm.id);
-                    if (existing) {
-                        const disabled = store.toggleAlarm(alarm.id, false);
-                        const snapshot = store.snapshot();
-                        alarmStateRef.current = snapshot.alarms;
-                        setLibrary(snapshot);
-                        setMessage(`Delete cleanup failed; ${disabled.label} was kept disabled so Repair can retry: ${messageOf(error)}`);
-                    }
-                    else
-                        setMessage(`Delete cleanup failed after the local alarm disappeared: ${messageOf(error)}`);
-                }).finally(() => { busyAlarmIdsRef.current.delete(alarm.id); setBusyAlarmIds(new Set(busyAlarmIdsRef.current)); void refreshRuntime(); });
+                void deleteAlarm(alarm).catch(error => setMessage(`Unexpected alarm deletion failure: ${messageOf(error)}`));
                 return true;
             }
             if (input !== 'x') {
@@ -677,7 +692,7 @@ export function useAlarmTui(params) {
             return true;
         }
         return false;
-    }, [activeAlarms, deletingId, draft, editSelected, editingField, editorControl, editorField, go, library.alarms, openForStation, pickerChoices, pickerFallback, previewStation, refreshActive, refreshRuntime, runVerification, saveDraft, screen, selected, service, setLibrary, setMessage, setSelected, snoozeMinutes, store, syncPersisted, timeSegment, verification, visibleFields, weekdayIndex]);
+    }, [activeAlarms, deleteAlarm, deletingId, draft, editSelected, editingField, editorControl, editorField, go, library.alarms, openForStation, pickerChoices, pickerFallback, previewStation, refreshActive, refreshRuntime, runVerification, saveDraft, screen, selected, service, setLibrary, setMessage, setSelected, snoozeMinutes, store, syncPersisted, timeSegment, verification, visibleFields, weekdayIndex]);
     const openActive = useCallback(() => {
         if (!activeAlarms.length) {
             setMessage('No alarm is currently playing.');

package/dist/ui/use-app-input.js

@@ -1,11 +1,15 @@
-import { useEffect } from 'react';
+import { useCallback, useEffect } from 'react';
 import { useInput } from 'ink';
 import { homeItems, settingsItemsForPage, settingsPageForRootItem } from './screen-items.js';
-import { applyTextInput, favoriteTarget, isEditableInput, isPlainPrintableInput, mediaTransportActionForInput, searchEditingArrowAction, shouldHandleKeyboardEvent, shouldToggleNearbyLocationShortcut } from './app-state.js';
+import { applyTextInput, favoriteTarget, isEditableInput, isPlainPrintableInput, isSearchFavoriteShortcut, mediaTransportActionForInput, searchEditingArrowAction, shouldHandleKeyboardEvent, shouldTuneSearchResult, shouldToggleNearbyLocationShortcut } from './app-state.js';
 import { parseTerminalMouseEvents, primaryMousePress, wheelScrollDelta } from './terminal-mouse.js';
 import { completeCommand } from './help-content.js';
 import { commitImmediateSelection } from './selection-state.js';
+import { sanitizeTerminalText } from '../safety.js';
 export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, cancelPendingAutoSkip, beginLearningTransportKey, capturingTransportAction, commandMode, commandText, confirmCtrlCExit, copyStationUrl, openStationHomepage, currentItemCount, cycleDisplayColor, cycleAudioOutput, cycleReceiverStyle, cycleSleepTimer, editingCountryFilter, editingSearch, executeCommand, filteredCountries, go, lastRawTransportAtRef, lastSubmittedSearchRef, loadCountry, openAdjacentTab, openAirPlayCode, openAirPlaySettings, openSettingsPage, closeSettingsPage, openScreen, handleAlarmInput, openAlarmForStation, openActiveAlarms, playAdjacent, playStation, player, playingStation, recallSearchHistory, moveExploreCursor, moveExploreCursorToCell, refreshAirPlayTargets, refreshProviderHealth, resetLearnedTransportKeys, repairMcpIntegrations, setAgentIntegrationEnabled, runSearch, saveLearnedTransportKey, screen, settingsPage, searchQuery, selectedRef, selectedStationForInput, selectAirPlayDeviceAt, setCapturingTransportAction, setAirPlayCode, setCommandMode, setCommandText, setCountryFilter, setEditingCountryFilter, setEditingSearch, setMessage, setSearchQuery, setSelected, setShowDiagnostics, submitAirPlayCode, settingsRef, shutdown, stdin, toggleFavorite, toggleMute, togglePause, toggleSetting, toggleAgentSetting, toggleNearbyLocation, toggleDirectoryVoting, toggleRadioGarden, toggleSkipBrokenStreams, updateFromSettings }) {
+    const reportInputError = useCallback((error) => {
+        setMessage(sanitizeTerminalText(error instanceof Error ? error.message : String(error)) ?? 'Could not complete this action.');
+    }, [setMessage]);
     const commitSelection = (next) => {
         commitImmediateSelection(selectedRef, setSelected, next, currentItemCount(screen));
     };
@@ -15,7 +19,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         commitSelection(selectedRef.current + delta);
     };
     useEffect(() => {
-        const onData = (data) => {
+        const handleData = (data) => {
             const rawInput = String(data);
             if (capturingTransportAction) {
                 if (rawInput === '\u001B') {
@@ -63,6 +67,14 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
                 togglePause();
             }
         };
+        const onData = (data) => {
+            try {
+                handleData(data);
+            }
+            catch (error) {
+                reportInputError(error);
+            }
+        };
         stdin.on('data', onData);
         return () => {
             stdin.off('data', onData);
@@ -78,6 +90,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         lastRawTransportAtRef,
         playAdjacent,
         player,
+        reportInputError,
         moveExploreCursorToCell,
         saveLearnedTransportKey,
         screen,
@@ -89,7 +102,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         stdin,
         togglePause
     ]);
-    useInput((input, key) => {
+    const handleInput = async (input, key) => {
         if (key.ctrl && input === 'c') {
             confirmCtrlCExit();
             return;
@@ -105,9 +118,9 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         }
         if (commandMode) {
             if (key.return) {
-                void executeCommand(commandText);
                 setCommandText('');
                 setCommandMode(false);
+                await executeCommand(commandText);
                 return;
             }
             if (key.escape) {
@@ -128,17 +141,21 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         if (handleAlarmInput(input, key)) {
             return;
         }
-        // An active text field owns its keystrokes before app-wide shortcuts. In
-        // particular, a normal "a" in a station query must not invoke the global
-        // schedule-this-station shortcut and leave Search for the alarm editor.
+        // An active text field owns ordinary keystrokes before app-wide shortcuts.
+        // Dedicated modified shortcuts are handled here so plain query characters
+        // never trigger actions or leave Search.
         if (screen === 'search' && editingSearch) {
+            if (isSearchFavoriteShortcut(input, key)) {
+                toggleFavorite(favoriteTarget(screen, selectedStationForInput(), playingStation));
+                return;
+            }
             if (key.return) {
                 const inputStation = selectedStationForInput();
-                if (searchQuery.trim() && searchQuery.trim() === lastSubmittedSearchRef.current && inputStation) {
-                    void playStation(inputStation);
+                if (inputStation && shouldTuneSearchResult(searchQuery, lastSubmittedSearchRef.current)) {
+                    await playStation(inputStation);
                 }
                 else {
-                    void runSearch();
+                    await runSearch();
                 }
                 return;
             }
@@ -240,7 +257,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         if (input.startsWith(':')) {
             const seed = input.slice(1).replace(/[\r\n]+$/g, '');
             if (/[\r\n]/.test(input)) {
-                void executeCommand(seed);
+                await executeCommand(seed);
             }
             else {
                 setCommandMode(true);
@@ -372,11 +389,11 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
             return;
         }
         if (input === 'O') {
-            openStationHomepage(favoriteTarget(screen, selectedStationForInput(), playingStation));
+            await openStationHomepage(favoriteTarget(screen, selectedStationForInput(), playingStation));
             return;
         }
         if (input === 'y') {
-            void copyStationUrl(favoriteTarget(screen, selectedStationForInput(), playingStation));
+            await copyStationUrl(favoriteTarget(screen, selectedStationForInput(), playingStation));
             return;
         }
         if (input === ' ') {
@@ -418,7 +435,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
             if (screen === 'countries') {
                 const country = filteredCountries[selectedRef.current];
                 if (country) {
-                    void loadCountry(country);
+                    await loadCountry(country);
                 }
                 return;
             }
@@ -483,10 +500,10 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
                     toggleSetting('automaticUpdateChecks');
                 }
                 else if (item === 'Allow local agent control') {
-                    void setAgentIntegrationEnabled();
+                    await setAgentIntegrationEnabled();
                 }
                 else if (item === 'Install or repair MCP integrations') {
-                    void repairMcpIntegrations();
+                    await repairMcpIntegrations();
                 }
                 else if (item === 'Open TUI for agent playback') {
                     toggleAgentSetting('openUiOnPlay');
@@ -498,12 +515,12 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
                     setCommandText('export ');
                     setCommandMode(true);
                 }
-                else if (item === 'Import preferences and library') {
-                    setCommandText('import ');
+                else if (item === 'Restore preferences and library') {
+                    setCommandText('restore ');
                     setCommandMode(true);
                 }
                 else if (item === 'Check for updates') {
-                    void updateFromSettings();
+                    await updateFromSettings();
                 }
                 else if (item === 'Refresh provider health') {
                     refreshProviderHealth();
@@ -530,15 +547,18 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
             if (screen === 'map') {
                 const country = filteredCountries[selectedRef.current];
                 if (country) {
-                    void loadCountry(country);
+                    await loadCountry(country);
                 }
                 return;
             }
             const inputStation = selectedStationForInput();
             if (inputStation) {
-                void playStation(inputStation);
+                await playStation(inputStation);
             }
         }
+    };
+    useInput((input, key) => {
+        void handleInput(input, key).catch(reportInputError);
     });
 }
 function shouldScrollSelectionWithWheel(screen, commandMode, editingCountryFilter) {

package/dist/ui/use-command-executor.js

@@ -1,6 +1,7 @@
 import { useCallback } from 'react';
 import { favoriteTarget, normalizeMediaKeyBindings, parseMediaActionName } from './app-state.js';
-export function useCommandExecutor({ beginLearningTransportKey, countries, go, loadCountry, openAirPlaySettings, openLibrary, player, playingStation, providers, resetLearnedTransportKeys, runSearch, screen, selectedStation, setCountries, setFilters, setLibrary, setMessage, setSearchQuery, setSleepUntil, setVolume, settingsRef, store, toggleFavorite, toggleMute, updateCommand, updateSettings }) {
+import { importStreamUrl } from '../streams/import-stream.js';
+export function useCommandExecutor({ beginLearningTransportKey, countries, go, loadCountry, openAirPlaySettings, openLibrary, persistLibrary, player, playingStation, providers, resetLearnedTransportKeys, runSearch, screen, selectedStation, setCountries, setFilters, setLibrary, setMessage, setSearchQuery, setSleepUntil, setVolume, settingsRef, store, toggleFavorite, toggleMute, updateCommand, updateSettings }) {
     return useCallback(async (rawCommand) => {
         const trimmed = rawCommand.trim();
         if (!trimmed) {
@@ -146,9 +147,31 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
             }
             return;
         }
-        if (name === 'import' || name === 'restore') {
+        if (name === 'import') {
             if (!value.trim()) {
-                setMessage('Usage: :import <backup.json>');
+                setMessage('Usage: :import <stream-url> [station name]');
+                return;
+            }
+            try {
+                const [url = '', ...nameParts] = rest;
+                setMessage('Reading stream metadata...');
+                const result = await importStreamUrl(url, nameParts.join(' ') || undefined);
+                const nextLibrary = persistLibrary(() => store.addImported([result.station]));
+                if (!nextLibrary)
+                    return;
+                openLibrary();
+                setMessage(result.warning
+                    ? `Imported ${result.station.name}. ${result.warning}`
+                    : `Imported ${result.station.name}${result.station.codec ? ` · ${result.station.codec}` : ''}${result.station.bitrate ? ` · ${result.station.bitrate} kbps` : ''}.`);
+            }
+            catch (error) {
+                setMessage(error instanceof Error ? error.message : 'Could not import the radio stream.');
+            }
+            return;
+        }
+        if (name === 'restore') {
+            if (!value.trim()) {
+                setMessage('Usage: :restore <backup.json>');
                 return;
             }
             try {
@@ -156,11 +179,11 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
                 settingsRef.current = result.state.settings;
                 setLibrary(result.state);
                 setMessage(result.safetyBackupPath
-                    ? `Backup imported. Previous library saved to ${result.safetyBackupPath}`
-                    : `Backup imported: ${result.sourcePath}`);
+                    ? `Backup restored. Previous library saved to ${result.safetyBackupPath}`
+                    : `Backup restored: ${result.sourcePath}`);
             }
             catch (error) {
-                setMessage(error instanceof Error ? error.message : 'Could not import the RadioCLI backup.');
+                setMessage(error instanceof Error ? error.message : 'Could not restore the RadioCLI backup.');
             }
             return;
         }
@@ -169,7 +192,7 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
             return;
         }
         if (name === 'stop') {
-            setLibrary(store.finishActiveListeningSession());
+            persistLibrary(() => store.finishActiveListeningSession());
             await player.stop();
             return;
         }
@@ -203,6 +226,7 @@ export function useCommandExecutor({ beginLearningTransportKey, countries, go, l
         loadCountry,
         openAirPlaySettings,
         openLibrary,
+        persistLibrary,
         player,
         playingStation,
         providers,

package/dist/update-check.js

@@ -1,15 +1,16 @@
 import { realpathSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import { appVersion } from './version.js';
+import { networkPolicy, withExternalResponse } from './platform/network.js';
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 const UPDATE_PACKAGE_NAME = '@ciphore/radiocli';
 export async function checkForUpdate({ currentVersion = appVersion(), fetchImpl = fetch, now = new Date(), packageName = UPDATE_PACKAGE_NAME, timeoutMs = 3000 } = {}) {
     try {
-        const response = await fetchWithTimeout(registryLatestUrl(packageName), fetchImpl, timeoutMs);
-        if (!response.ok) {
-            throw new Error(`npm registry returned ${response.status}`);
-        }
-        const parsed = await response.json();
+        const parsed = await withExternalResponse(registryLatestUrl(packageName), { fetchImpl, timeoutMs }, async (response) => {
+            if (!response.ok)
+                throw new Error(`npm registry returned ${response.status}`);
+            return await response.json();
+        });
         const latestVersion = typeof parsed.version === 'string' ? parsed.version : undefined;
         if (!latestVersion) {
             throw new Error('npm registry response did not include a version');
@@ -31,7 +32,7 @@ export async function checkForUpdate({ currentVersion = appVersion(), fetchImpl
     }
 }
 export function shouldCheckForUpdate(updateCheck, now = Date.now()) {
-    if (process.env.RADIOCLI_DISABLE_UPDATE_CHECK === '1' || process.env.CI === 'true') {
+    if (!automaticUpdateChecksAllowed()) {
         return false;
     }
     if (!updateCheck?.checkedAt) {
@@ -41,7 +42,7 @@ export function shouldCheckForUpdate(updateCheck, now = Date.now()) {
     return !Number.isFinite(checkedAt) || now - checkedAt >= UPDATE_CHECK_INTERVAL_MS;
 }
 export function automaticUpdateChecksAllowed(enabled = true) {
-    return enabled && process.env.RADIOCLI_DISABLE_UPDATE_CHECK !== '1' && process.env.CI !== 'true';
+    return enabled && !networkPolicy().offline && process.env.RADIOCLI_DISABLE_UPDATE_CHECK !== '1' && process.env.CI !== 'true';
 }
 export function updateAvailableForVersion(updateCheck, currentVersion = updateCheck?.currentVersion) {
     return Boolean(updateCheck?.updateAvailable &&
@@ -113,16 +114,6 @@ export function compareSemver(left, right) {
 function registryLatestUrl(packageName) {
     return `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`;
 }
-async function fetchWithTimeout(url, fetchImpl, timeoutMs) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetchImpl(url, { signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 function semverParts(version) {
     const normalized = version.trim().replace(/^v/i, '').split(/[+-]/)[0] ?? '';
     const [major = '0', minor = '0', patch = '0'] = normalized.split('.');