@ciphore/radiocli 0.2.1 → 0.2.3

package/dist/agent/cli.js

@@ -0,0 +1,193 @@
+import { AgentRadioService, stationForAgent } from './service.js';
+import { configureMcpIntegrations, mcpIntegrationReport, portableMcpConfig } from './mcp-install.js';
+import { runMcpServer } from './mcp-server.js';
+export async function runMcpCommand(args, runtime) {
+    const command = args[0] ?? 'status';
+    if (command === 'serve')
+        return runMcpServer(runtime);
+    if (command === 'enable' || command === 'install' || command === 'repair') {
+        assertMcpInstallSucceeded(await configureMcpIntegrations(true, runtime), 'configured');
+        return;
+    }
+    if (command === 'disable' || command === 'remove') {
+        assertMcpInstallSucceeded(await configureMcpIntegrations(false, runtime), 'removed');
+        return;
+    }
+    if (command === 'config') {
+        console.log(JSON.stringify(portableMcpConfig(runtime), null, 2));
+        return;
+    }
+    if (command === 'status' || command === 'doctor') {
+        console.log(JSON.stringify(await mcpIntegrationReport(runtime), null, 2));
+        return;
+    }
+    throw new Error('Usage: radiocli mcp <enable|install|repair|disable|status|config|serve>');
+}
+export async function runAgentCliCommand(args, runtime) {
+    const service = new AgentRadioService(runtime);
+    const [command = 'status', ...rest] = args;
+    let value;
+    if (command === 'status')
+        value = await service.status();
+    else if (command === 'search')
+        value = (await service.search(requiredText(rest, 'Usage: radiocli agent search <query>'))).map(stationForAgent);
+    else if (command === 'browse') {
+        const kind = parseBrowseKind(rest[0]);
+        if (rest.length > 2)
+            throw new Error('Usage: radiocli agent browse [favorites|recent|popular|nearby|countries|track-history] [1-50]');
+        const items = await service.browse(kind, rest[1] === undefined ? 20 : integerInRange(rest[1], 1, 50, 'Browse limit'));
+        value = ['favorites', 'recent', 'popular', 'nearby'].includes(kind)
+            ? items.map(stationForAgent)
+            : items;
+    }
+    else if (command === 'play')
+        value = await service.play(parsePlayArgs(rest));
+    else if (command === 'pause' || command === 'resume' || command === 'stop' || command === 'next' || command === 'previous')
+        value = await service.control({ type: command });
+    else if (command === 'volume') {
+        if (rest.length !== 1)
+            throw new Error('Usage: radiocli agent volume <0-100>');
+        value = await service.control({ type: 'set-volume', volume: numberInRange(rest[0], 0, 100, 'Volume') });
+    }
+    else if (command === 'mute' || command === 'unmute')
+        value = await service.control({ type: 'set-muted', muted: command === 'mute' });
+    else if (command === 'favorite' || command === 'unfavorite')
+        value = await service.setFavorite(command === 'favorite', rest[0]);
+    else if (command === 'stats')
+        value = service.stats();
+    else if (command === 'appearance')
+        value = await parseAppearance(rest, service);
+    else if (command === 'airplay')
+        value = await runAirPlayCommand(rest, service);
+    else if (command === 'preset')
+        value = service.configureCompletionPreset(parsePreset(rest));
+    else if (command === 'done')
+        value = await service.runCompletionPreset();
+    else
+        throw new Error('Usage: radiocli agent <status|search|browse|play|pause|resume|stop|next|previous|volume|mute|unmute|favorite|unfavorite|stats|appearance|airplay|preset|done>');
+    console.log(JSON.stringify(value, null, 2));
+}
+function parseBrowseKind(value) {
+    const kind = value ?? 'recent';
+    if (!['favorites', 'recent', 'popular', 'nearby', 'countries', 'track-history'].includes(kind))
+        throw new Error('Browse kind must be favorites, recent, popular, nearby, countries, or track-history.');
+    return kind;
+}
+function parsePlayArgs(args) {
+    const result = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--source')
+            result.source = stationSource(required(args[++index], '--source requires recent, favorite, popular, or country.'));
+        else if (arg === '--country') {
+            result.source = 'country';
+            result.countryCode = countryCode(required(args[++index], '--country requires a two-letter code.'));
+        }
+        else if (arg === '--random')
+            result.random = true;
+        else if (arg === '--no-ui')
+            result.openUi = false;
+        else if (arg === '--keep-playing')
+            result.ifPlaying = 'keep';
+        else if (!result.stationId)
+            result.stationId = arg;
+        else
+            throw new Error(`Unknown play option: ${arg}`);
+    }
+    return result;
+}
+function parseAppearance(args, service) {
+    if (args.length === 0)
+        return service.appearance();
+    const input = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--theme')
+            input.theme = required(args[++index], '--theme requires a theme name.');
+        else if (arg === '--receiver-style')
+            input.receiverStyle = required(args[++index], '--receiver-style requires a style name.');
+        else
+            throw new Error(`Unknown appearance option: ${arg}`);
+    }
+    return service.updateAppearance(input);
+}
+function parsePreset(args) {
+    const input = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--action')
+            input.action = presetAction(required(args[++index], '--action requires play, pause, resume, or stop.'));
+        else if (arg === '--source')
+            input.source = stationSource(required(args[++index], '--source requires recent, favorite, popular, or country.'));
+        else if (arg === '--country') {
+            input.source = 'country';
+            input.countryCode = countryCode(required(args[++index], '--country requires a two-letter code.'));
+        }
+        else if (arg === '--keep-playing')
+            input.ifPlaying = 'keep';
+        else if (arg === '--replace')
+            input.ifPlaying = 'replace';
+        else if (arg === '--open-ui')
+            input.openUi = true;
+        else if (arg === '--no-ui')
+            input.openUi = false;
+        else
+            throw new Error(`Unknown preset option: ${arg}`);
+    }
+    return input;
+}
+async function runAirPlayCommand(args, service) {
+    const [action = 'list', ...rest] = args;
+    if (action === 'list')
+        return service.listAirPlayDevices();
+    if (action === 'select')
+        return service.selectAirPlayDevice(required(rest[0], 'Usage: radiocli agent airplay select <receiver-id>'), !rest.includes('--no-ui'));
+    if (action === 'local')
+        return service.useLocalOutput();
+    if (action === 'code')
+        return service.submitAirPlayPasscode(required(rest[0], 'Usage: radiocli agent airplay code <receiver-code>'));
+    throw new Error('Usage: radiocli agent airplay <list|select|local|code>');
+}
+function required(value, error) { if (!value)
+    throw new Error(error); return value; }
+function requiredText(values, error) {
+    const value = values.join(' ').trim();
+    if (!value)
+        throw new Error(error);
+    return value;
+}
+function numberInRange(value, minimum, maximum, label) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < minimum || parsed > maximum) {
+        throw new Error(`${label} must be a number from ${minimum} through ${maximum}.`);
+    }
+    return parsed;
+}
+function integerInRange(value, minimum, maximum, label) {
+    const parsed = numberInRange(value, minimum, maximum, label);
+    if (!Number.isInteger(parsed))
+        throw new Error(`${label} must be a whole number from ${minimum} through ${maximum}.`);
+    return parsed;
+}
+function stationSource(value) {
+    if (!['recent', 'favorite', 'popular', 'country'].includes(value)) {
+        throw new Error('Source must be recent, favorite, popular, or country.');
+    }
+    return value;
+}
+function presetAction(value) {
+    if (!['play', 'pause', 'resume', 'stop'].includes(value))
+        throw new Error('Action must be play, pause, resume, or stop.');
+    return value;
+}
+function countryCode(value) {
+    if (!/^[a-z]{2}$/i.test(value))
+        throw new Error('Country must be a two-letter ISO country code.');
+    return value.toUpperCase();
+}
+function assertMcpInstallSucceeded(results, action) {
+    const failed = results.filter(result => result.status === 'failed');
+    if (failed.length === 0)
+        return;
+    throw new Error(`RadioCLI was ${action} where possible, but ${failed.length} integration${failed.length === 1 ? '' : 's'} failed: ${failed.map(result => `${result.client} (${result.detail})`).join('; ')}`);
+}

package/dist/agent/headless-host.js

@@ -0,0 +1,143 @@
+import { PlayerController } from '../player/player-controller.js';
+import { ProviderManager } from '../providers/provider-manager.js';
+import { JsonLibraryStore, stationKey } from '../storage/store.js';
+import { startRadioSession } from './session.js';
+import { detectPlaybackBackends } from '../player/backend-install.js';
+export async function runHeadlessAgentHost() {
+    const store = new JsonLibraryStore();
+    const providers = new ProviderManager();
+    const player = new PlayerController(() => store.snapshot().settings);
+    player.refreshDetectedBackends();
+    let station = null;
+    let queue = [];
+    const status = () => ({ owner: 'headless', playback: player.getState(), station, queue, output: {
+            preferredBackend: store.snapshot().settings.preferredBackend,
+            preferredAirPlayDevice: store.snapshot().settings.preferredAirPlayDevice
+        } });
+    const result = (message, ok = true, data) => ({ ok, message, status: status(), ...(data ? { data } : {}) });
+    const play = async (next, nextQueue = [next]) => {
+        store.finishActiveListeningSession();
+        await player.stop();
+        const resolved = await providers.resolve(next);
+        await player.play(next, resolved.url);
+        station = next;
+        queue = nextQueue.length ? nextQueue : [next];
+        store.addRecent(next);
+        store.startListeningSession(next);
+        return result(`Playing ${next.name}.`);
+    };
+    const handle = async (command) => {
+        if (command.type === 'status')
+            return result(station ? `${player.getState().state}: ${station.name}` : 'RadioCLI is idle.');
+        if (command.type === 'play') {
+            if (command.ifPlaying === 'keep' && ['playing', 'paused', 'loading'].includes(player.getState().state))
+                return result(`Kept current station ${station?.name ?? ''}.`);
+            return play(command.station, command.queue);
+        }
+        if (command.type === 'pause') {
+            const control = await player.pause();
+            if (control.ok)
+                store.finishActiveListeningSession();
+            return result(control.message ?? 'Paused.', control.ok);
+        }
+        if (command.type === 'resume') {
+            const control = await player.resume();
+            if (control.ok && station)
+                store.startListeningSession(station);
+            return result(control.message ?? 'Resumed.', control.ok);
+        }
+        if (command.type === 'stop') {
+            store.finishActiveListeningSession();
+            await player.stop();
+            station = null;
+            queue = [];
+            setTimeout(() => process.kill(process.pid, 'SIGTERM'), 50).unref();
+            return result('Stopped RadioCLI.');
+        }
+        if (command.type === 'alarm-preempt') {
+            store.finishActiveListeningSession();
+            await player.stop();
+            station = null;
+            queue = [];
+            return result('Interactive playback yielded to the alarm.');
+        }
+        if (command.type === 'set-volume') {
+            const control = await player.setVolume(command.volume);
+            if (control.ok)
+                store.updateSettings({ volume: player.getState().volume });
+            return result(control.message ?? `Volume ${player.getState().volume}.`, control.ok);
+        }
+        if (command.type === 'set-muted') {
+            const control = await player.setMuted(command.muted);
+            return result(control.message ?? (command.muted ? 'Muted.' : 'Unmuted.'), control.ok);
+        }
+        if (command.type === 'set-favorite') {
+            const target = command.station ?? station;
+            if (!target)
+                return result('No active station to favorite.', false);
+            const current = store.isFavorite(target);
+            if (current !== command.favorite)
+                store.toggleFavorite(target);
+            if (command.favorite && !current && store.snapshot().settings.shareDirectoryVotes)
+                void providers.vote(target);
+            return result(`${command.favorite ? 'Favorited' : 'Removed favorite'}: ${target.name}.`);
+        }
+        if (command.type === 'airplay-list') {
+            const devices = await player.refreshAirPlayDevices();
+            return result(devices.length ? `${devices.length} AirPlay receiver(s) found.` : 'No AirPlay receivers found.', true, devices);
+        }
+        if (command.type === 'airplay-select') {
+            const devices = await player.refreshAirPlayDevices();
+            const device = devices.find(item => item.id === command.deviceId);
+            if (!device)
+                return result('AirPlay receiver not found. Refresh and use an exact receiver ID.', false, devices);
+            if (device.local)
+                return switchToLocal();
+            if (!detectPlaybackBackends().includes('airplay'))
+                return result('AirPlay playback is unavailable; run radiocli doctor.', false);
+            store.updateSettings({ preferredAirPlayDevice: device.id });
+            store.updateSettings({ preferredBackend: 'airplay' });
+            if (station && ['playing', 'paused', 'loading'].includes(player.getState().state))
+                return play(station, queue);
+            return result(`Audio output set to AirPlay receiver ${device.name}.`);
+        }
+        if (command.type === 'airplay-local')
+            return switchToLocal();
+        if (command.type === 'airplay-passcode') {
+            const control = player.submitAirPlayPasscode(command.code);
+            return result(control.message ?? 'AirPlay code sent.', control.ok);
+        }
+        if (command.type === 'update-settings') {
+            store.updateSettings(command.settings);
+            return result('RadioCLI settings updated.');
+        }
+        const currentIndex = station ? queue.findIndex(item => stationKey(item) === stationKey(station)) : -1;
+        const delta = command.type === 'next' ? 1 : -1;
+        const next = queue.length ? queue[(Math.max(0, currentIndex) + delta + queue.length) % queue.length] : undefined;
+        return next ? play(next, queue) : result('No playback queue is available.', false);
+    };
+    const switchToLocal = async () => {
+        const backends = detectPlaybackBackends();
+        const backend = backends.includes('mpv') ? 'mpv' : backends.includes('ffplay') ? 'ffplay' : backends.includes('vlc') ? 'vlc' : null;
+        if (!backend)
+            return result('No local playback backend is available. Run radiocli setup to install mpv.', false);
+        store.updateSettings({ preferredBackend: backend });
+        if (station && ['playing', 'paused', 'loading'].includes(player.getState().state))
+            return play(station, queue);
+        return result(`Audio output set to this device (${backend}).`);
+    };
+    const session = await startRadioSession(handle);
+    const checkpoint = setInterval(() => {
+        if (player.getState().state === 'playing')
+            store.checkpointActiveListeningSession();
+    }, 30_000);
+    const shutdown = async () => {
+        clearInterval(checkpoint);
+        store.finishActiveListeningSession();
+        await player.stop();
+        await session.close();
+    };
+    process.once('SIGTERM', () => { void shutdown().finally(() => process.exit(0)); });
+    process.once('SIGINT', () => { void shutdown().finally(() => process.exit(0)); });
+    await new Promise(() => undefined);
+}

package/dist/agent/launcher.js

@@ -0,0 +1,71 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { detectAlarmTerminal } from '../alarms/terminal-launcher.js';
+const linuxTerminals = new Set(['alacritty', 'foot', 'ghostty', 'gnome-terminal', 'kitty', 'konsole', 'mate-terminal', 'qterminal', 'terminator', 'tilix', 'wezterm', 'xfce4-terminal', 'x-terminal-emulator']);
+export async function launchRadioTui(nodePath, cliPath, encodedCommand) {
+    const terminal = detectAlarmTerminal();
+    const direct = environmentCommand(nodePath, cliPath, ['agent-ui', encodedCommand]);
+    const command = `${direct.map(shellQuote).join(' ')}`;
+    if (terminal === 'darwin:apple-terminal')
+        await launched(spawnDetached('/usr/bin/osascript', appleTerminalScript(command)));
+    else if (terminal === 'darwin:iterm')
+        await launched(spawnDetached('/usr/bin/osascript', iTermScript(command)));
+    else if (terminal === 'darwin:wezterm')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'WezTerm', '--args', 'start', '--always-new-process', '--', ...direct]));
+    else if (terminal === 'darwin:ghostty')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'Ghostty', '--args', '-e', ...direct]));
+    else if (terminal === 'darwin:kitty')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'kitty', '--args', '--detach', ...direct]));
+    else if (terminal === 'win32:windows-terminal')
+        await launched(spawnDetached('wt.exe', ['-w', 'new', 'new-tab', '--title', 'RadioCLI', ...direct]));
+    else if (terminal === 'win32:console')
+        await launched(spawnDetached('cmd.exe', ['/d', '/c', 'start', 'RadioCLI', 'cmd.exe', '/k', windowsCommand(direct)]));
+    else if (terminal.startsWith('linux:')) {
+        const executable = terminal.slice('linux:'.length);
+        if (!linuxTerminals.has(basename(executable)))
+            throw new Error('Saved Linux terminal is not supported.');
+        const name = basename(executable);
+        const prefix = name === 'gnome-terminal' || name === 'mate-terminal' || name === 'xfce4-terminal'
+            ? ['--']
+            : name === 'wezterm' ? ['start', '--always-new-process', '--'] : ['-e'];
+        await launched(spawnDetached(executable, [...prefix, ...direct]));
+    }
+    else {
+        throw new Error('No supported graphical terminal was found. Set agentControl.openUiOnPlay to false or open radiocli manually.');
+    }
+}
+export async function launchHeadlessHost(nodePath, cliPath) {
+    await launched(spawnDetached(nodePath, [cliPath, 'agent-host']));
+}
+function environmentCommand(nodePath, cliPath, args) {
+    const command = [nodePath, cliPath, ...args];
+    const radioCliHome = process.env.RADIOCLI_HOME;
+    if (!radioCliHome)
+        return command;
+    if (process.platform === 'win32') {
+        return ['cmd.exe', '/d', '/c', `set "RADIOCLI_HOME=${cmdEscape(radioCliHome)}" && ${windowsCommand(command)}`];
+    }
+    return ['/usr/bin/env', `RADIOCLI_HOME=${radioCliHome}`, ...command];
+}
+function shellQuote(value) { return `'${value.replaceAll("'", `'\\''`)}'`; }
+function windowsCommand(values) { return values.map(value => `"${value.replaceAll('"', '""')}"`).join(' '); }
+function cmdEscape(value) { return value.replaceAll('%', '%%').replaceAll('"', '""').replaceAll('^', '^^').replaceAll('&', '^&').replaceAll('|', '^|').replaceAll('<', '^<').replaceAll('>', '^>'); }
+function appleTerminalScript(command) { return ['-e', 'on run argv', '-e', 'tell application "Terminal"', '-e', 'activate', '-e', 'do script (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }
+function iTermScript(command) { return ['-e', 'on run argv', '-e', 'tell application "iTerm"', '-e', 'activate', '-e', 'set w to (create window with default profile)', '-e', 'tell current session of w to write text (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }
+function spawnDetached(command, args) { return spawn(command, [...args], { detached: true, stdio: 'ignore', windowsHide: false }); }
+function launched(child) { return new Promise((resolve, reject) => { child.once('error', reject); child.once('spawn', () => { child.unref(); resolve(); }); }); }
+export function resolveExecutable(input, env = process.env, platform = process.platform) {
+    if ((input.includes('/') || input.includes('\\')) && existsSync(input))
+        return input;
+    const suffixes = platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    const pathDelimiter = platform === 'win32' ? ';' : ':';
+    for (const directory of (env.PATH ?? '').split(pathDelimiter)) {
+        for (const suffix of suffixes) {
+            const path = join(directory, `${input}${suffix}`);
+            if (existsSync(path))
+                return path;
+        }
+    }
+    return undefined;
+}