@ciphore/radiocli 0.2.3 → 0.2.5

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/text-direction.js

@@ -0,0 +1,9 @@
+import { rightToLeftPattern, strongDirectionPattern } from './bidi-ranges.js';
+/** First-strong direction for single-line text sanitized by sanitizeTerminalText. */
+export function textDirection(text) {
+    // UAX #9 P2/P3: numbers, combining marks, emoji and punctuation generally
+    // don't establish direction. Inspect the whole name, never the moving slice.
+    // Pinned bidi classes avoid relying on locale or the host's ICU version.
+    const first = strongDirectionPattern.exec(text)?.[0];
+    return first && rightToLeftPattern.test(first) ? 'rtl' : 'ltr';
+}

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

@@ -3,7 +3,12 @@ import { applyTextInput, clamp, isEditableInput } from './app-state.js';
 import { adjustTime, alarmEditorFields, alarmInputFromDraft, alarmTextFields, cycleWeekdays, defaultAlarmDraft, draftFromAlarm, toggleWeekday, validateAlarmDraft } from './alarm-editor.js';
 import { alarmPickerChoices } from './screens/AlarmsScreen.js';
 export function useAlarmTui(params) {
-    const { service, store, library, setLibrary, screen, selected, setSelected, go, setMessage, playingStation, previewStation } = params;
+    const { service, store, library, setLibrary, screen, screenRef, selected, selectedRef, setSelected: setSelectionState, go, setMessage, playingStation, previewStation } = params;
+    const setSelected = useCallback(next => {
+        const value = typeof next === 'function' ? next(selectedRef.current) : next;
+        selectedRef.current = value;
+        setSelectionState(value);
+    }, [selectedRef, setSelectionState]);
     const [draft, setDraft] = useState(null);
     const [editingField, setEditingField] = useState(false);
     const [editorControl, setEditorControl] = useState(null);
@@ -38,8 +43,6 @@ export function useAlarmTui(params) {
     const activeSelectedKeyRef = useRef(undefined);
     const pendingActiveActionsRef = useRef(new Set());
     const acknowledgedActiveKeysRef = useRef(new Set());
-    const screenRef = useRef(screen);
-    screenRef.current = screen;
     const alarmsRef = useRef(library.alarms);
     alarmsRef.current = library.alarms;
     const visibleFields = useMemo(() => alarmEditorFields.filter(field => {
@@ -67,14 +70,16 @@ export function useAlarmTui(params) {
         for (const key of pendingActiveActionsRef.current)
             if (!liveKeys.has(key))
                 pendingActiveActionsRef.current.delete(key);
-        activeAlarmsRef.current = sessions;
-        setActiveAlarms(sessions);
+        if (JSON.stringify(activeAlarmsRef.current) !== JSON.stringify(sessions)) {
+            activeAlarmsRef.current = sessions;
+            setActiveAlarms(sessions);
+        }
         if (sessions.length > 0 && activeCountRef.current === 0 && screenRef.current !== 'alarm-ringing') {
             returnScreenRef.current = screenRef.current;
             go('alarm-ringing', { resetSelection: true, clearMessage: false });
         }
         activeCountRef.current = sessions.length;
-    }, [go]);
+    }, [go, screenRef]);
     const refreshActive = useCallback(async () => {
         if (activePollingRef.current)
             return;
@@ -180,7 +185,41 @@ export function useAlarmTui(params) {
         }
         await refreshRuntime();
     }, [refreshRuntime, service, setMessage]);
-    const saveDraft = useCallback(() => {
+    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 = await store.toggleAlarm(alarm.id, false);
+            const disabledSnapshot = store.snapshot();
+            alarmStateRef.current = disabledSnapshot.alarms;
+            setLibrary(disabledSnapshot);
+            phase = 'native';
+            await service.remove(disabled);
+            phase = 'definition';
+            await 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(async () => {
         if (!draft || savingRef.current)
             return;
         const error = validateAlarmDraft(draft);
@@ -193,7 +232,7 @@ export function useAlarmTui(params) {
         setSaving(true);
         try {
             const input = alarmInputFromDraft(draft);
-            const alarm = draft.id ? store.updateAlarm(draft.id, input) : store.addAlarm(input);
+            const alarm = draft.id ? await store.updateAlarm(draft.id, input) : await store.addAlarm(input);
             setLibrary(store.snapshot());
             setValidationError(null);
             go('alarms', { resetSelection: true, clearMessage: false });
@@ -212,7 +251,7 @@ export function useAlarmTui(params) {
         setSaving(false);
     }, [draft, go, setLibrary, setMessage, store, syncPersisted]);
     const editSelected = useCallback(() => {
-        const alarm = alarmStateRef.current[selected - 1];
+        const alarm = alarmStateRef.current[selectedRef.current - 1];
         if (!alarm)
             return;
         setDraft(draftFromAlarm(alarm));
@@ -226,7 +265,7 @@ export function useAlarmTui(params) {
         setValidationError(null);
         setSelected(0);
         go('alarm-editor', { resetSelection: true });
-    }, [go, library.alarms, selected, setSelected]);
+    }, [go, selectedRef, setSelected]);
     const runVerification = useCallback(() => {
         if (verificationRunningRef.current)
             return;
@@ -243,6 +282,9 @@ export function useAlarmTui(params) {
         void service.verifySetup(alarm, library.settings, update => setVerification(update)).then(report => { setVerification(report); setMessage(report.state === 'passed' ? 'Alarm setup verified. This machine completed every rehearsal step.' : report.state === 'warning' ? 'Alarm setup works, with limitations shown in the verification report.' : 'Alarm setup verification found blockers. Review the failed steps before relying on it.'); }).catch(error => { setVerification(current => ({ ...current ?? initial, state: 'failed', finishedAt: new Date().toISOString(), steps: [...(current?.steps ?? []), { id: 'internal', label: 'Verification runner', state: 'failed', detail: messageOf(error), critical: true }] })); setMessage(`Alarm setup verification failed: ${messageOf(error)}`); }).finally(() => { verificationRunningRef.current = false; void refreshRuntime(); });
     }, [library.settings, refreshRuntime, service, setMessage, store]);
     const handleInput = useCallback((input, key) => {
+        const screen = screenRef.current;
+        const selected = selectedRef.current;
+        const editorField = visibleFields[clamp(selected, visibleFields.length - 1)] ?? 'label';
         if (!['alarms', 'alarm-editor', 'alarm-picker', 'alarm-ringing'].includes(screen))
             return false;
         if (key.scrollDelta) {
@@ -321,11 +363,7 @@ export function useAlarmTui(params) {
                 return true;
             }
             if (input === ' ' && alarm) {
-                const updated = store.toggleAlarm(alarm.id);
-                const snapshot = store.snapshot();
-                alarmStateRef.current = snapshot.alarms;
-                setLibrary(snapshot);
-                void syncPersisted(updated, `${updated.enabled ? 'Enabled' : 'Disabled'} ${updated.label}.`);
+                void (async () => { const updated = await store.toggleAlarm(alarm.id); const snapshot = store.snapshot(); alarmStateRef.current = snapshot.alarms; setLibrary(snapshot); await syncPersisted(updated, `${updated.enabled ? 'Enabled' : 'Disabled'} ${updated.label}.`); })().catch(error => setMessage(`Alarm save failed: ${messageOf(error)}`));
                 return true;
             }
             if (input === 'x' && alarm) {
@@ -343,26 +381,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') {
@@ -393,11 +412,7 @@ export function useAlarmTui(params) {
                 return true;
             }
             if (input === 'g' && alarm) {
-                const updated = store.updateAlarm(alarm.id, { reliability: { ...alarm.reliability, keepAwakeUntilAlarm: !alarm.reliability.keepAwakeUntilAlarm } });
-                const snapshot = store.snapshot();
-                alarmStateRef.current = snapshot.alarms;
-                setLibrary(snapshot);
-                void syncPersisted(updated, `Alarm Guard ${updated.reliability.keepAwakeUntilAlarm ? 'on' : 'off'} for ${alarm.label}.`);
+                void (async () => { const updated = await store.updateAlarm(alarm.id, { reliability: { ...alarm.reliability, keepAwakeUntilAlarm: !alarm.reliability.keepAwakeUntilAlarm } }); const snapshot = store.snapshot(); alarmStateRef.current = snapshot.alarms; setLibrary(snapshot); await syncPersisted(updated, `Alarm Guard ${updated.reliability.keepAwakeUntilAlarm ? 'on' : 'off'} for ${alarm.label}.`); })().catch(error => setMessage(`Alarm save failed: ${messageOf(error)}`));
                 return true;
             }
             if (input === 'b' || key.escape) {
@@ -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, go, library.alarms, openForStation, pickerChoices, pickerFallback, previewStation, refreshActive, refreshRuntime, runVerification, saveDraft, screenRef, selectedRef, service, setLibrary, setMessage, setSelected, snoozeMinutes, store, syncPersisted, timeSegment, verification, visibleFields, weekdayIndex]);
     const openActive = useCallback(() => {
         if (!activeAlarms.length) {
             setMessage('No alarm is currently playing.');
@@ -689,7 +704,7 @@ export function useAlarmTui(params) {
         activeSelectedKeyRef.current = activeAlarms[0]?.key;
         setActiveSelected(0);
         go('alarm-ringing', { resetSelection: true, clearMessage: false });
-    }, [activeAlarms, go, setMessage]);
+    }, [activeAlarms, go, screenRef, setMessage]);
     return { draft, editorField, editingField, editorControl, timeSegment, weekdayIndex, validationError, saving, pickerChoices, pickerFallback, runtime, verification, activeAlarms, activeSelected, snoozeMinutes, deletingId, busyAlarmIds, itemCount(current) { if (current === 'alarms')
             return library.alarms.length + 2; if (current === 'alarm-editor')
             return visibleFields.length; if (current === 'alarm-picker')

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

@@ -1,21 +1,26 @@
-import { useEffect } from 'react';
-import { useInput } from 'ink';
+import { useCallback, useEffect } from 'react';
+import { useInput, usePaste } 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 { completeCommand, commandNamesForAirPlay } from './help-content.js';
 import { commitImmediateSelection } from './selection-state.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 }) {
+import { sanitizeTerminalText } from '../safety.js';
+export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, airPlaySupported, 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, screenRef, settingsPageRef, 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));
+        commitImmediateSelection(selectedRef, setSelected, next, currentItemCount(screenRef.current));
     };
     const moveSelection = (delta) => {
-        if (hasStationSelection(screen))
+        if (hasStationSelection(screenRef.current))
             cancelPendingAutoSkip();
         commitSelection(selectedRef.current + delta);
     };
     useEffect(() => {
-        const onData = (data) => {
+        const handleData = (data) => {
+            const screen = screenRef.current;
             const rawInput = String(data);
             if (capturingTransportAction) {
                 if (rawInput === '\u001B') {
@@ -63,6 +68,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,9 +91,11 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         lastRawTransportAtRef,
         playAdjacent,
         player,
+        reportInputError,
         moveExploreCursorToCell,
         saveLearnedTransportKey,
         screen,
+        screenRef,
         selectedRef,
         setCapturingTransportAction,
         setMessage,
@@ -89,7 +104,9 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         stdin,
         togglePause
     ]);
-    useInput((input, key) => {
+    const handleInput = async (input, key) => {
+        const screen = screenRef.current;
+        const settingsPage = settingsPageRef.current;
         if (key.ctrl && input === 'c') {
             confirmCtrlCExit();
             return;
@@ -100,14 +117,17 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
         if (capturingTransportAction) {
             return;
         }
-        if (Date.now() - lastRawTransportAtRef.current < 50) {
+        // Suppress only the mouse/media event already handled by the raw listener.
+        // Other keys in the same chunk (or immediately afterward) must still work.
+        const editingPlainText = isPlainPrintableInput(input) && (commandMode || (screen === 'search' && editingSearch) || ((screen === 'countries' || screen === 'map') && editingCountryFilter));
+        if (!editingPlainText && Date.now() - lastRawTransportAtRef.current < 50 && isRawInputEcho(input, key, settingsRef.current)) {
             return;
         }
         if (commandMode) {
             if (key.return) {
-                void executeCommand(commandText);
                 setCommandText('');
                 setCommandMode(false);
+                await executeCommand(commandText);
                 return;
             }
             if (key.escape) {
@@ -117,7 +137,7 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
             }
             if (key.tab) {
                 // Complete the command name only while still typing it (no args yet).
-                setCommandText(value => (/\s/.test(value) ? value : completeCommand(value)));
+                setCommandText(value => (/\s/.test(value) ? value : completeCommand(value, commandNamesForAirPlay(airPlaySupported))));
                 return;
             }
             if (isEditableInput(input, key)) {
@@ -128,17 +148,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 +264,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 +396,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,12 +442,12 @@ export function useAppInput({ adjustVolume, airPlayCode, canEnterAirPlayCode, ca
             if (screen === 'countries') {
                 const country = filteredCountries[selectedRef.current];
                 if (country) {
-                    void loadCountry(country);
+                    await loadCountry(country);
                 }
                 return;
             }
             if (screen === 'settings') {
-                const item = settingsItemsForPage(settingsPage)[selectedRef.current];
+                const item = settingsItemsForPage(settingsPage, airPlaySupported)[selectedRef.current];
                 if (settingsPage === 'root') {
                     const targetPage = settingsPageForRootItem(item);
                     if (targetPage) {
@@ -483,10 +507,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 +522,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,17 +554,47 @@ 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) => {
+        // Ink preserves non-escape text chunks for paste, including repeated Tab
+        // bytes. Only a chunk consisting entirely of Tabs represents navigation.
+        if (/^\t{2,}$/.test(input)) {
+            for (let index = 0; index < input.length; index += 1) {
+                void handleInput('', { ...key, tab: true }).catch(reportInputError);
+            }
+            return;
+        }
+        void handleInput(input, key).catch(reportInputError);
+    });
+    // Keep bracketed paste on its own channel so pasted Tabs stay text. The
+    // existing text/command handling still receives each complete pasted string.
+    usePaste(input => {
+        void handleInput(input, pasteInputKey).catch(reportInputError);
     });
 }
+const pasteInputKey = {
+    upArrow: false, downArrow: false, leftArrow: false, rightArrow: false,
+    pageDown: false, pageUp: false, home: false, end: false,
+    return: false, escape: false, ctrl: false, shift: false, tab: false,
+    backspace: false, delete: false, meta: false,
+    super: false, hyper: false, capsLock: false, numLock: false
+};
+function isRawInputEcho(input, key, settings) {
+    return Boolean(mediaTransportActionForInput(input, settings.mediaKeys) ||
+        mediaTransportActionForInput(`\u001B${input}`, settings.mediaKeys) ||
+        ((key.shift || key.ctrl || key.meta) && (key.leftArrow || key.rightArrow)) ||
+        /^\[<\d+;\d+;\d+[Mm]$/.test(input) ||
+        input.startsWith('[M'));
+}
 function shouldScrollSelectionWithWheel(screen, commandMode, editingCountryFilter) {
     if (commandMode || editingCountryFilter) {
         return false;