@ciphore/radiocli 0.2.2 → 0.2.4

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,165 @@
+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 { airPlayMacOSOnlyMessage, detectPlaybackBackends, isAirPlayPlatformSupported } 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 = [];
+    let persistenceWarning;
+    const persistHistory = (write) => {
+        try {
+            write();
+        }
+        catch (error) {
+            const code = error?.code;
+            const detail = typeof code === 'string' && /^[A-Z][A-Z0-9_]+$/.test(code) ? ` (${code})` : '';
+            persistenceWarning = `Listening history was not saved${detail}. Check storage permissions or set RADIOCLI_HOME to a private writable directory.`;
+        }
+    };
+    const saveLibrary = (write) => {
+        write();
+        // Optional writes can be no-ops, so only an explicit successful save clears
+        // a prior warning. Explicit failures still reject the control request.
+        persistenceWarning = undefined;
+    };
+    const status = () => ({ owner: 'headless', playback: player.getState(), station, queue, persistenceWarning, 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]) => {
+        persistHistory(() => store.finishActiveListeningSession());
+        await player.stop();
+        const resolved = await providers.resolve(next);
+        await player.play(next, resolved.url);
+        station = next;
+        queue = nextQueue.length ? nextQueue : [next];
+        persistHistory(() => store.addRecent(next));
+        persistHistory(() => store.startListeningSession(next));
+        return result(`Playing ${next.name}.`);
+    };
+    const handle = async (command) => {
+        if (['airplay-list', 'airplay-select', 'airplay-passcode'].includes(command.type) && !isAirPlayPlatformSupported()) {
+            return result(airPlayMacOSOnlyMessage, false, command.type === 'airplay-list' ? [] : undefined);
+        }
+        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)
+                persistHistory(() => store.finishActiveListeningSession());
+            return result(control.message ?? 'Paused.', control.ok);
+        }
+        if (command.type === 'resume') {
+            const control = await player.resume();
+            if (control.ok && station)
+                persistHistory(() => store.startListeningSession(station));
+            return result(control.message ?? 'Resumed.', control.ok);
+        }
+        if (command.type === 'stop') {
+            persistHistory(() => 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') {
+            persistHistory(() => 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)
+                saveLibrary(() => 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)
+                saveLibrary(() => 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);
+            saveLibrary(() => {
+                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') {
+            saveLibrary(() => 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);
+        saveLibrary(() => 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')
+            persistHistory(() => store.checkpointActiveListeningSession());
+    }, 30_000);
+    const shutdown = async () => {
+        clearInterval(checkpoint);
+        persistHistory(() => 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,10 @@
+import { spawn } from 'node:child_process';
+import { launchTerminalCommand } from '../platform/terminals.js';
+import { waitForLaunch } from '../platform/launch-command.js';
+/** The agent service verifies the authenticated session after this request. */
+export async function launchRadioTui(nodePath, cliPath, encodedCommand, options = {}) {
+    await launchTerminalCommand({ ...options, nodePath, args: [cliPath, 'agent-ui', encodedCommand], title: 'RadioCLI' });
+}
+export async function launchHeadlessHost(nodePath, cliPath) {
+    await waitForLaunch(spawn(nodePath, [cliPath, 'agent-host'], { detached: true, stdio: 'ignore', windowsHide: false }));
+}