@ciphore/radiocli 0.2.1 → 0.2.3

package/dist/agent/service.js

@@ -0,0 +1,347 @@
+import { randomInt } from 'node:crypto';
+import { defaultAgentControlSettings, themeNames, receiverStyleNames } from '../types.js';
+import { JsonLibraryStore, stationKey } from '../storage/store.js';
+import { ProviderManager } from '../providers/provider-manager.js';
+import { computeListeningStats } from '../activity/stats.js';
+import { connectActiveAlarms } from '../alarms/active-session.js';
+import { connectRadioSession, ensureRadioSession } from './session.js';
+import { launchHeadlessHost, launchRadioTui } from './launcher.js';
+import { PlayerController } from '../player/player-controller.js';
+import { detectPlaybackBackends } from '../player/backend-install.js';
+import { AgentAlarmService } from './alarm-service.js';
+import { appVersion } from '../version.js';
+import { checkForUpdate, updateCommandForInstall } from '../update-check.js';
+export class AgentRadioService {
+    runtime;
+    store;
+    providers;
+    stationCache = new Map();
+    alarms;
+    constructor(runtime, store = new JsonLibraryStore(), providers = new ProviderManager()) {
+        this.runtime = runtime;
+        this.store = store;
+        this.providers = providers;
+        this.alarms = new AgentAlarmService(this.store, id => this.resolveStationId(id), undefined, status => this.handoffAlarm(status));
+    }
+    settings() { return this.store.snapshot().settings; }
+    appearance() {
+        this.assertEnabled();
+        return { themes: themeNames, receiverStyles: receiverStyleNames, current: this.settings() };
+    }
+    async status() {
+        this.assertEnabled();
+        const client = await connectRadioSession();
+        const state = this.store.snapshot();
+        return {
+            connected: Boolean(client),
+            session: client ? await client.status() : null,
+            agentControl: this.agentSettings(),
+            favoriteCount: state.favorites.length,
+            recentCount: state.recent.length,
+            alarmActive: (await connectActiveAlarms()).length > 0,
+            audioOutput: {
+                preferredBackend: state.settings.preferredBackend,
+                preferredAirPlayDevice: state.settings.preferredAirPlayDevice
+            }
+        };
+    }
+    async updateStatus() {
+        this.assertEnabled();
+        const update = await checkForUpdate();
+        const install = updateCommandForInstall();
+        return {
+            installedVersion: appVersion(),
+            latestVersion: update.latestVersion ?? null,
+            updateAvailable: update.updateAvailable,
+            checkedAt: update.checkedAt,
+            error: update.error ?? null,
+            installMethod: install.method,
+            command: install.command,
+            note: 'RadioCLI does not install updates through MCP. Ask the user to approve the command or use Settings, then restart the MCP client.'
+        };
+    }
+    async search(query, limit = 10, countryCode) {
+        this.assertEnabled();
+        const stations = await this.providers.search(query, this.store.snapshot().settings, {
+            limit: clampLimit(limit),
+            countryCode
+        });
+        this.remember(stations);
+        return stations;
+    }
+    async browse(kind, limit = 20) {
+        this.assertEnabled();
+        const state = this.store.snapshot();
+        const bounded = clampLimit(limit, 50);
+        if (kind === 'favorites')
+            return this.remember(state.favorites.slice(0, bounded));
+        if (kind === 'recent')
+            return this.remember(state.recent.slice(0, bounded).map(item => item.station));
+        if (kind === 'track-history')
+            return state.trackHistory.slice(0, bounded);
+        if (kind === 'countries')
+            return this.providers.countries(bounded);
+        if (kind === 'popular')
+            return this.remember(await this.providers.popular(bounded));
+        if (!state.settings.enableNearbyLocation)
+            throw new Error('Nearby location lookup is disabled in RadioCLI settings.');
+        const location = await this.providers.detectLocation();
+        if (!location)
+            throw new Error('RadioCLI could not determine an approximate location.');
+        return this.remember(await this.providers.nearby(location, bounded));
+    }
+    stats() {
+        this.assertEnabled();
+        return computeListeningStats(this.store.snapshot().activity.sessions);
+    }
+    async play(input) {
+        this.assertEnabled();
+        if ((await connectActiveAlarms()).length > 0)
+            throw new Error('An alarm is currently active. Dismiss or keep the alarm from its ringing controls before starting interactive playback.');
+        const queue = await this.stationQueue(input.source ?? 'recent', input.countryCode);
+        if (!input.stationId && queue.length === 0)
+            throw new Error('No station is available for that request.');
+        const station = input.stationId
+            ? await this.findStation(input.stationId, queue)
+            : queue[input.random ? randomInt(queue.length) : Math.max(0, input.index ?? 0)];
+        if (!station)
+            throw new Error(input.stationId ? `Unknown station ID: ${input.stationId}. Search or browse first.` : 'No station is available for that request.');
+        const ordered = [station, ...queue.filter(item => stationKey(item) !== stationKey(station))];
+        return this.send({
+            type: 'play',
+            station,
+            queue: ordered,
+            openNowPlaying: this.agentSettings().focusNowPlaying,
+            ifPlaying: input.ifPlaying ?? 'replace'
+        }, input.openUi);
+    }
+    async control(command, openUi) {
+        this.assertEnabled();
+        const client = await connectRadioSession();
+        if (!client && command.type === 'set-volume') {
+            const volume = Math.min(100, Math.max(0, command.volume));
+            this.store.updateSettings({ volume });
+            return idleResult(`Saved volume ${volume}; no playback session is active.`);
+        }
+        if (!client && ['stop', 'pause', 'resume', 'next', 'previous', 'set-volume', 'set-muted'].includes(command.type)) {
+            if (command.type === 'stop' || command.type === 'pause')
+                return idleResult(command.type === 'stop' ? 'RadioCLI is already stopped.' : 'No playback session is active; pause is already satisfied.');
+            throw new Error('No interactive RadioCLI playback session is active.');
+        }
+        return this.send(command, openUi);
+    }
+    async setFavorite(favorite, stationId) {
+        this.assertEnabled();
+        const client = await connectRadioSession();
+        if (!stationId && client)
+            return client.call({ type: 'set-favorite', favorite });
+        const station = stationId ? await this.findStation(stationId, this.savedStations()) : undefined;
+        if (!station)
+            throw new Error('No station was supplied and no active station is available.');
+        const isFavorite = this.store.isFavorite(station);
+        if (isFavorite !== favorite)
+            this.store.toggleFavorite(station);
+        if (favorite && !isFavorite && this.store.snapshot().settings.shareDirectoryVotes)
+            void this.providers.vote(station);
+        return { ok: true, message: `${favorite ? 'Favorited' : 'Removed favorite'}: ${station.name}`, station };
+    }
+    async updateAppearance(input) {
+        this.assertEnabled();
+        if (input.theme && !themeNames.includes(input.theme))
+            throw new Error(`Unknown theme: ${input.theme}`);
+        if (input.receiverStyle && !receiverStyleNames.includes(input.receiverStyle))
+            throw new Error(`Unknown receiver style: ${input.receiverStyle}`);
+        const client = await connectRadioSession();
+        if (client)
+            return client.call({ type: 'update-settings', settings: input });
+        return this.store.updateSettings(input).settings;
+    }
+    async runCompletionPreset() {
+        const preset = this.agentSettings().completionPreset;
+        if (preset.action === 'play')
+            return this.play({ source: preset.source, countryCode: preset.countryCode, random: preset.source !== 'recent', openUi: preset.openUi, ifPlaying: preset.ifPlaying });
+        return this.control({ type: preset.action }, preset.openUi);
+    }
+    configureCompletionPreset(input) {
+        this.assertEnabled();
+        const agentControl = this.agentSettings();
+        const completionPreset = { ...agentControl.completionPreset, ...input };
+        if (completionPreset.source === 'country' && !completionPreset.countryCode)
+            throw new Error('A two-letter countryCode is required for the country preset source.');
+        if (completionPreset.countryCode)
+            completionPreset.countryCode = completionPreset.countryCode.toUpperCase();
+        return this.store.updateSettings({ agentControl: { ...agentControl, completionPreset } }).settings.agentControl;
+    }
+    async updateAgentPreferences(input) {
+        this.assertEnabled();
+        const agentControl = { ...this.agentSettings(), ...input };
+        const client = await connectRadioSession();
+        if (client)
+            return client.call({ type: 'update-settings', settings: { agentControl } });
+        return this.store.updateSettings({ agentControl }).settings.agentControl;
+    }
+    alarmList() { this.assertEnabled(); return this.alarms.list(); }
+    alarmStatus() { this.assertEnabled(); return this.alarms.status(); }
+    alarmCreate(input) { this.assertEnabled(); return this.alarms.create(input); }
+    alarmUpdate(id, input) { this.assertEnabled(); return this.alarms.update(id, input); }
+    alarmSetEnabled(id, enabled) { this.assertEnabled(); return this.alarms.setEnabled(id, enabled); }
+    alarmRemove(id, confirm) { this.assertEnabled(); return this.alarms.remove(id, confirm); }
+    alarmSync() { this.assertEnabled(); return this.alarms.sync(); }
+    alarmControl(input) { this.assertEnabled(); return this.alarms.controlActive(input); }
+    async listAirPlayDevices() {
+        this.assertEnabled();
+        this.assertAirPlayPlatform();
+        const client = await connectRadioSession();
+        if (client)
+            return (await client.call({ type: 'airplay-list' })).data ?? [];
+        const player = new PlayerController(() => this.store.snapshot().settings);
+        const backends = player.refreshDetectedBackends();
+        if (!backends.includes('airplay'))
+            throw new Error('AirPlay is unavailable on this Mac. Run radiocli doctor to check ffmpeg, dns-sd, and the sender package.');
+        return player.refreshAirPlayDevices();
+    }
+    async selectAirPlayDevice(deviceId, openUi) {
+        this.assertEnabled();
+        this.assertAirPlayPlatform();
+        const devices = await this.listAirPlayDevices();
+        const device = devices.find(item => item.id === deviceId);
+        if (!device)
+            throw new Error('Unknown AirPlay receiver ID. Refresh the receiver list and use an exact returned ID.');
+        if (device.local)
+            return this.useLocalOutput(openUi);
+        this.store.updateSettings({ preferredAirPlayDevice: device.id });
+        return this.send({ type: 'airplay-select', deviceId: device.id }, openUi);
+    }
+    async useLocalOutput(openUi) {
+        this.assertEnabled();
+        const client = await connectRadioSession();
+        if (!client) {
+            const backend = preferredLocalBackend(detectPlaybackBackends());
+            if (!backend)
+                throw new Error('No local playback backend is available. Run radiocli setup to install mpv.');
+            this.store.updateSettings({ preferredBackend: backend });
+            return idleResult(`Audio output set to this device (${backend}).`);
+        }
+        return this.send({ type: 'airplay-local' }, openUi);
+    }
+    async submitAirPlayPasscode(code) {
+        this.assertEnabled();
+        this.assertAirPlayPlatform();
+        const client = await connectRadioSession();
+        if (!client)
+            throw new Error('No active AirPlay session is waiting for a receiver code.');
+        return client.call({ type: 'airplay-passcode', code });
+    }
+    async resolveStationId(id) {
+        return this.findStation(id, this.savedStations());
+    }
+    async handoffAlarm(status) {
+        if (!status.station)
+            throw new Error('This alarm session does not expose a station for interactive handoff.');
+        const result = await this.send({
+            type: 'play',
+            station: status.station,
+            queue: [status.station],
+            openNowPlaying: true,
+            ifPlaying: 'replace'
+        }, undefined, true);
+        if (!result.ok || result.status.playback.state !== 'playing' || !result.status.playback.ready) {
+            throw new Error(result.message || 'Interactive playback did not become ready; the alarm is still playing.');
+        }
+    }
+    async send(command, openUi, allowActiveAlarm = false) {
+        const settings = this.settings();
+        const agentControl = settings.agentControl ?? defaultAgentControlSettings;
+        if (!agentControl.enabled)
+            throw new Error('Agent control is disabled. Run radiocli mcp enable or enable it in Settings.');
+        let client = await connectRadioSession();
+        if (!client) {
+            if (!allowActiveAlarm && (await connectActiveAlarms()).length > 0)
+                throw new Error('An alarm is currently active. Dismiss or keep the alarm from its ringing controls before starting interactive playback.');
+            const shouldOpen = openUi ?? agentControl.openUiOnPlay;
+            client = await ensureRadioSession(async () => {
+                if (shouldOpen)
+                    await launchRadioTui(this.runtime.nodePath, this.runtime.cliPath, encodeAgentCommand({ type: 'status' }));
+                else
+                    await launchHeadlessHost(this.runtime.nodePath, this.runtime.cliPath);
+            });
+        }
+        return client.call(command);
+    }
+    async stationQueue(source, countryCode) {
+        const state = this.store.snapshot();
+        let stations;
+        if (source === 'recent')
+            stations = state.recent.map(item => item.station);
+        else if (source === 'favorite')
+            stations = state.favorites;
+        else if (source === 'popular')
+            stations = await this.providers.popular(50);
+        else {
+            if (!countryCode || !/^[a-z]{2}$/i.test(countryCode))
+                throw new Error('countryCode must be a two-letter ISO country code.');
+            stations = await this.providers.byCountry(countryCode.toUpperCase(), 100);
+        }
+        return this.remember(stations);
+    }
+    savedStations() {
+        const state = this.store.snapshot();
+        return [...state.favorites, ...state.recent.map(item => item.station), ...state.imported, ...this.stationCache.values()];
+    }
+    async findStation(id, candidates) {
+        const normalized = id.trim();
+        const local = this.stationCache.get(normalized)
+            ?? candidates.find(station => opaqueStationId(station) === normalized || station.id === normalized);
+        if (local)
+            return local;
+        const separator = normalized.indexOf(':');
+        const provider = separator > 0 ? normalized.slice(0, separator) : 'radio-browser';
+        const providerId = separator > 0 ? normalized.slice(separator + 1) : normalized;
+        if (!['radio-browser', 'radio-garden', 'playlist'].includes(provider))
+            return undefined;
+        const station = await this.providers.byId(provider, providerId);
+        if (station)
+            this.remember([station]);
+        return station ?? undefined;
+    }
+    remember(stations) {
+        for (const station of stations)
+            this.stationCache.set(opaqueStationId(station), station);
+        return stations;
+    }
+    agentSettings() {
+        return this.settings().agentControl ?? defaultAgentControlSettings;
+    }
+    assertEnabled() {
+        if (!this.agentSettings().enabled)
+            throw new Error('Agent control is disabled. Run radiocli mcp enable or enable it in Settings.');
+    }
+    assertAirPlayPlatform() {
+        if (process.platform !== 'darwin')
+            throw new Error('AirPlay control is available only on macOS.');
+    }
+}
+function opaqueStationId(station) { return `${station.provider}:${station.id}`; }
+export function stationForAgent(station) {
+    return {
+        id: opaqueStationId(station),
+        name: station.name,
+        country: station.country,
+        countryCode: station.countryCode,
+        city: station.city,
+        language: station.language,
+        tags: station.tags.slice(0, 8),
+        codec: station.codec,
+        bitrate: station.bitrate,
+        distanceKm: station.distanceKm
+    };
+}
+function encodeAgentCommand(command) { return Buffer.from(JSON.stringify(command)).toString('base64url'); }
+export function decodeAgentCommand(value) { return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')); }
+function clampLimit(value, max = 30) { return Math.min(max, Math.max(1, Math.round(value))); }
+function idleResult(message) {
+    return { ok: true, message, status: { owner: 'headless', station: null, queue: [], playback: { backend: 'none', state: 'idle', volume: 70, muted: false, ready: false } } };
+}
+function preferredLocalBackend(backends) {
+    return backends.includes('mpv') ? 'mpv' : backends.includes('ffplay') ? 'ffplay' : backends.includes('vlc') ? 'vlc' : null;
+}

package/dist/agent/session.js

@@ -0,0 +1,248 @@
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, openSync, closeSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { createServer, request } from 'node:http';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+export async function startRadioSession(handle, filePath = radioSessionPath()) {
+    const ownerPath = `${filePath}.owner`;
+    acquireOwner(ownerPath);
+    const token = randomBytes(32).toString('hex');
+    let serial = Promise.resolve();
+    const server = createServer((req, res) => {
+        res.setHeader('content-type', 'application/json');
+        if (req.headers.authorization !== `Bearer ${token}`) {
+            res.statusCode = 401;
+            res.end('{}');
+            return;
+        }
+        if (req.method !== 'POST' || req.url !== '/command') {
+            res.statusCode = 404;
+            res.end('{}');
+            return;
+        }
+        const work = serial.then(async () => {
+            const body = await readBody(req);
+            return handle(JSON.parse(body));
+        });
+        serial = work.then(() => undefined, () => undefined);
+        void work.then(result => res.end(JSON.stringify(result))).catch(error => {
+            res.statusCode = 400;
+            res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Radio control failed.' }));
+        });
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => resolve());
+        });
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new Error('Unable to create RadioCLI control endpoint.');
+        const discovery = {
+            version: 1,
+            host: '127.0.0.1',
+            port: address.port,
+            token,
+            pid: process.pid,
+            createdAt: new Date().toISOString()
+        };
+        writePrivateJson(filePath, discovery);
+        return {
+            async close() {
+                await new Promise(resolve => server.close(() => resolve()));
+                removeIfOwned(filePath, discovery);
+                removeOwner(ownerPath, process.pid);
+            }
+        };
+    }
+    catch (error) {
+        removeOwner(ownerPath, process.pid);
+        await new Promise(resolve => server.close(() => resolve()));
+        throw error;
+    }
+}
+export async function connectRadioSession(filePath = radioSessionPath()) {
+    if (!existsSync(filePath))
+        return null;
+    let discovery;
+    try {
+        discovery = JSON.parse(readFileSync(filePath, 'utf8'));
+        if (discovery.version !== 1 || discovery.host !== '127.0.0.1' || !Number.isInteger(discovery.port) || !discovery.token) {
+            throw new Error('invalid');
+        }
+    }
+    catch {
+        rmSync(filePath, { force: true });
+        return null;
+    }
+    const call = async (command) => {
+        const payload = JSON.stringify(command);
+        return new Promise((resolve, reject) => {
+            const req = request({
+                host: '127.0.0.1',
+                port: discovery.port,
+                path: '/command',
+                method: 'POST',
+                headers: {
+                    authorization: `Bearer ${discovery.token}`,
+                    'content-type': 'application/json',
+                    'content-length': Buffer.byteLength(payload)
+                }
+            }, res => {
+                let text = '';
+                res.on('data', value => { text += String(value); });
+                res.on('end', () => {
+                    if (res.statusCode && res.statusCode < 300)
+                        resolve(JSON.parse(text));
+                    else
+                        reject(new Error(parseError(text)));
+                });
+            });
+            req.once('error', reject);
+            req.setTimeout(15_000, () => req.destroy(new Error('RadioCLI control request timed out.')));
+            req.end(payload);
+        });
+    };
+    try {
+        await call({ type: 'status' });
+        return { call, status: async () => (await call({ type: 'status' })).status };
+    }
+    catch {
+        if (!processAlive(discovery.pid) || discoveryAgeMs(filePath, discovery) > 60_000) {
+            removeIfOwned(filePath, discovery);
+            removeOwner(`${filePath}.owner`, discovery.pid);
+        }
+        return null;
+    }
+}
+export async function ensureRadioSession(start, timeoutMs = 15_000) {
+    const existing = await connectRadioSession();
+    if (existing)
+        return existing;
+    const lockPath = `${radioSessionPath()}.launch`;
+    let ownsLaunch = false;
+    try {
+        acquireOwner(lockPath);
+        ownsLaunch = true;
+        const appeared = await connectRadioSession();
+        if (appeared)
+            return appeared;
+        await start();
+        return await waitForSession(timeoutMs);
+    }
+    catch (error) {
+        if (ownsLaunch || !(error instanceof Error) || !error.message.includes('already active'))
+            throw error;
+        return waitForSession(timeoutMs);
+    }
+    finally {
+        if (ownsLaunch)
+            removeOwner(lockPath, process.pid);
+    }
+}
+function radioSessionPath() {
+    return join(runtimeDirectory(), 'agent-session.json');
+}
+async function waitForSession(timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const client = await connectRadioSession();
+        if (client)
+            return client;
+        await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    throw new Error('RadioCLI was launched but its control session did not become ready.');
+}
+function runtimeDirectory() {
+    if (process.env.RADIOCLI_HOME)
+        return join(process.env.RADIOCLI_HOME, 'runtime');
+    if (process.platform === 'win32')
+        return join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'RadioCLI', 'runtime');
+    return join(process.env.XDG_RUNTIME_DIR ?? join(homedir(), '.local', 'state'), 'radiocli');
+}
+function acquireOwner(path) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        try {
+            const fd = openSync(path, 'wx', 0o600);
+            writeFileSync(fd, `${process.pid}\n`);
+            closeSync(fd);
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const pid = Number(readFileSync(path, 'utf8').trim());
+            if (processAlive(pid))
+                throw new Error('Another RadioCLI playback session is already active.');
+            rmSync(path, { force: true });
+        }
+    }
+    throw new Error('Could not claim the RadioCLI playback session.');
+}
+function removeOwner(path, pid) {
+    try {
+        if (Number(readFileSync(path, 'utf8').trim()) === pid)
+            rmSync(path, { force: true });
+    }
+    catch { }
+}
+function writePrivateJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temp = `${path}.tmp-${process.pid}-${randomBytes(6).toString('hex')}`;
+    writeFileSync(temp, `${JSON.stringify(value)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+    if (process.platform !== 'win32')
+        chmodSync(path, 0o600);
+}
+function removeIfOwned(path, owner) {
+    try {
+        const current = JSON.parse(readFileSync(path, 'utf8'));
+        if (current.pid === owner.pid && current.token === owner.token && current.port === owner.port)
+            rmSync(path, { force: true });
+    }
+    catch { }
+}
+function processAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function discoveryAgeMs(path, discovery) {
+    const created = Date.parse(discovery.createdAt);
+    if (Number.isFinite(created))
+        return Math.max(0, Date.now() - created);
+    try {
+        return Math.max(0, Date.now() - statSync(path).mtimeMs);
+    }
+    catch {
+        return 0;
+    }
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        let body = '';
+        req.on('data', value => {
+            body += String(value);
+            if (body.length > 1_000_000)
+                req.destroy(new Error('Request too large.'));
+        });
+        req.on('end', () => resolve(body));
+        req.on('error', reject);
+    });
+}
+function parseError(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed.error === 'string' ? parsed.error : 'RadioCLI control request failed.';
+    }
+    catch {
+        return 'RadioCLI control request failed.';
+    }
+}