@ciphore/radiocli 0.2.3 → 0.2.5

package/dist/agent/mcp-install.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'node:path';
 import { applyEdits, modify, parse } from 'jsonc-parser';
 import { JsonLibraryStore } from '../storage/store.js';
 import { defaultAgentControlSettings } from '../types.js';
-import { resolveExecutable } from './launcher.js';
+import { resolveCommandDetails } from '../platform/executables.js';
 const formatting = { insertSpaces: true, tabSize: 2, eol: '\n' };
 export async function configureMcpIntegrations(enabled, runtime, output = process.stdout) {
     const store = new JsonLibraryStore();
@@ -31,7 +31,7 @@ export async function configureMcpIntegrations(enabled, runtime, output = proces
     }
     else
         results.push(notFound('Codex'));
-    const claude = resolveExecutable('claude');
+    const claude = resolveCommandDetails('claude', { env: process.env }).path;
     if (claude) {
         results.push(await configureCliClient('Claude Code', claude, enabled
             ? ['mcp', 'add', '--scope', 'user', 'radiocli', '--', ...command]
@@ -40,7 +40,7 @@ export async function configureMcpIntegrations(enabled, runtime, output = proces
     else
         results.push(notFound('Claude Code'));
     const openCodePath = openCodeConfigPath();
-    if (resolveExecutable('opencode') || existsSync(openCodePath)) {
+    if (resolveCommandDetails('opencode', { env: process.env }).path || existsSync(openCodePath)) {
         try {
             updateOpenCodeConfig(openCodePath, enabled, command);
             results.push({ client: 'OpenCode', status: enabled ? 'configured' : 'removed', detail: openCodePath });
@@ -54,13 +54,13 @@ export async function configureMcpIntegrations(enabled, runtime, output = proces
     configureJsonClient(results, 'Cursor', cursorDetected(), join(homedir(), '.cursor', 'mcp.json'), ['mcpServers', 'radiocli'], enabled, {
         command: command[0], args: command.slice(1)
     });
-    configureJsonClient(results, 'Gemini CLI', Boolean(resolveExecutable('gemini')), join(homedir(), '.gemini', 'settings.json'), ['mcpServers', 'radiocli'], enabled, {
+    configureJsonClient(results, 'Gemini CLI', Boolean(resolveCommandDetails('gemini', { env: process.env }).path), join(homedir(), '.gemini', 'settings.json'), ['mcpServers', 'radiocli'], enabled, {
         command: command[0], args: command.slice(1)
     });
     configureJsonClient(results, 'VS Code / Copilot Agent Host', vsCodeDetected(), join(homedir(), '.copilot', 'mcp-config.json'), ['servers', 'radiocli'], enabled, {
         type: 'stdio', command: command[0], args: command.slice(1)
     });
-    if (resolveExecutable('orca')) {
+    if (resolveCommandDetails('orca', { env: process.env }).path) {
         results.push({ client: 'Orca', status: 'inherited', detail: 'Orca exposes MCP integrations through its configured Codex/Claude agent runtimes.' });
     }
     else
@@ -182,7 +182,7 @@ export function probeMcpServer(command, timeoutMs = 5_000) {
     });
 }
 function matchingRadioCliShim(runtime, platform) {
-    const candidate = resolveExecutable('radiocli', process.env, platform);
+    const candidate = resolveCommandDetails('radiocli', { env: process.env, platform }).path;
     if (!candidate)
         return undefined;
     if (!usableDirectLauncher(candidate, platform))
@@ -204,16 +204,16 @@ async function mcpClientStates(command) {
     const vscodePath = join(homedir(), '.copilot', 'mcp-config.json');
     return {
         codex: await codexClientState(resolveCodexExecutable(), command),
-        claude: await claudeClientState(resolveExecutable('claude'), command),
-        opencode: jsonClientState(Boolean(resolveExecutable('opencode') || existsSync(openCodePath)), openCodePath, [
+        claude: await claudeClientState(resolveCommandDetails('claude', { env: process.env }).path, command),
+        opencode: jsonClientState(Boolean(resolveCommandDetails('opencode', { env: process.env }).path || existsSync(openCodePath)), openCodePath, [
             ['mcp', 'servers', 'radiocli'], ['mcp', 'radiocli']
         ], command),
         cursor: jsonClientState(cursorDetected(), cursorPath, [['mcpServers', 'radiocli']], command),
-        gemini: jsonClientState(Boolean(resolveExecutable('gemini')), geminiPath, [['mcpServers', 'radiocli']], command),
+        gemini: jsonClientState(Boolean(resolveCommandDetails('gemini', { env: process.env }).path), geminiPath, [['mcpServers', 'radiocli']], command),
         vscode: jsonClientState(vsCodeDetected(), vscodePath, [['servers', 'radiocli']], command),
         orca: {
-            detected: Boolean(resolveExecutable('orca')),
-            state: resolveExecutable('orca') ? 'managed-by-client' : 'not-found',
+            detected: Boolean(resolveCommandDetails('orca', { env: process.env }).path),
+            state: resolveCommandDetails('orca', { env: process.env }).path ? 'managed-by-client' : 'not-found',
             detail: 'inherits MCP configuration from its Codex or Claude runtime'
         },
         portable: jsonClientState(true, portableConfigPath(), [['mcpServers', 'radiocli']], command)
@@ -226,7 +226,7 @@ export function resolveCodexExecutable(env = process.env, platform = process.pla
     const configured = env.CODEX_CLI_PATH;
     if (configured && existsSync(configured))
         return configured;
-    const pathExecutable = resolveExecutable('codex', env, platform);
+    const pathExecutable = resolveCommandDetails('codex', { env, platform, home }).path;
     if (pathExecutable)
         return pathExecutable;
     const candidates = platform === 'darwin'
@@ -243,14 +243,14 @@ export function resolveCodexExecutable(env = process.env, platform = process.pla
     return candidates.find(candidate => existsSync(candidate));
 }
 function cursorDetected() {
-    return Boolean(resolveExecutable('cursor') ||
-        resolveExecutable('cursor-agent') ||
+    return Boolean(resolveCommandDetails('cursor', { env: process.env }).path ||
+        resolveCommandDetails('cursor-agent', { env: process.env }).path ||
         existsSync(join(homedir(), '.cursor')) ||
         (process.platform === 'darwin' && existsSync('/Applications/Cursor.app')) ||
         (process.platform === 'win32' && existsSync(join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'Programs', 'cursor', 'Cursor.exe'))));
 }
 function vsCodeDetected() {
-    return Boolean(resolveExecutable('code') ||
+    return Boolean(resolveCommandDetails('code', { env: process.env }).path ||
         (process.platform === 'darwin' && existsSync('/Applications/Visual Studio Code.app')) ||
         (process.platform === 'win32' && existsSync(join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'Programs', 'Microsoft VS Code', 'Code.exe'))));
 }

package/dist/agent/mcp-server.js

@@ -1,14 +1,16 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { serveStdio } from '@modelcontextprotocol/server/stdio';
 import { z } from 'zod';
+import { JsonLibraryStore } from '../storage/store.js';
+import { LibraryRepository } from '../storage/repository.js';
 import { appVersion } from '../version.js';
 import { receiverStyleNames, themeNames } from '../types.js';
 import { AgentRadioService, stationForAgent } from './service.js';
 export const radioCliMcpInstructions = `RadioCLI is the authoritative handler for requests about RadioCLI, “the radio”, “my radio”, recent stations, favorites, or stations from a place. Never substitute a web browser, web search, Computer Use, or another radio/music service. “Play my most recent radio station” means call radio_play with source="recent" and index=0. “Play a station from New York” means call radio_search with query="New York", then radio_play with one returned opaque station ID. Call these tools directly; do not delegate a radio-only operation or create a goal merely to monitor it.
 
-RadioCLI controls internet radio, alarms, and macOS AirPlay locally. Discover unidentified stations with radio_search or radio_browse, then use only returned opaque IDs; never invent IDs or stream URLs. Ordinary stop never dismisses an alarm: list active alarms and use alarm controls, with an exact ID when several ring. Never remove an alarm without explicit user confirmation. List AirPlay receivers before selecting one. Never install an update without explicit approval.
+RadioCLI controls internet radio, alarms, and experimental AirPlay locally. Discover unidentified stations with radio_search or radio_browse, then use only returned opaque IDs; never invent IDs or stream URLs. Ordinary stop never dismisses an alarm: list active alarms and use alarm controls, with an exact ID when several ring. Never remove an alarm without explicit user confirmation. List AirPlay receivers before selecting one. Never install an update without explicit approval.
 
-For “this station”, omit station_id when favoriting. A request such as “do X, then play or stop the radio” is a normal completion action in the current task: perform X, then call radio_run_completion_preset once X is genuinely complete. Do not create or set a goal, scheduled task, automation, reminder, task record, or separate monitoring task merely to defer or track that radio action. Use one of those mechanisms only when the user explicitly requests it for a separate reason. AirPlay is macOS-only. Submit a receiver code only when the user provides it; codes are never saved. Use radio_update_status for version or upgrade questions, and tell the user to restart their MCP client after an update.`;
+For “this station”, omit station_id when favoriting. A request such as “do X, then play or stop the radio” is a normal completion action in the current task: perform X, then call radio_run_completion_preset once X is genuinely complete. Do not create or set a goal, scheduled task, automation, reminder, task record, or separate monitoring task merely to defer or track that radio action. Use one of those mechanisms only when the user explicitly requests it for a separate reason. AirPlay is experimental on macOS and native Linux; Linux receiver selection is required each session. Submit a receiver code only when the user provides it; codes are never saved. Use radio_update_status for version or upgrade questions, and tell the user to restart their MCP client after an update.`;
 const alarmScheduleSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('once'), at: z.string().min(1).describe('Absolute ISO-8601 minute including an offset or Z, with zero seconds.') }),
     z.object({
@@ -30,7 +32,9 @@ const alarmOptionsSchema = {
     keep_awake_until_alarm: z.boolean().optional()
 };
 export async function runMcpServer(runtime) {
-    const service = new AgentRadioService(runtime);
+    const store = new LibraryRepository(new JsonLibraryStore());
+    const service = new AgentRadioService(runtime, store);
+    process.once('beforeExit', () => { void store.close().catch(() => undefined); });
     serveStdio(() => createMcpServer(service), { onerror: error => console.error(`RadioCLI MCP: ${error.message}`) });
 }
 function createMcpServer(service) {
@@ -39,6 +43,7 @@ function createMcpServer(service) {
         const config = schema ? { description, inputSchema: schema } : { description };
         server.registerTool(name, config, async (raw) => {
             try {
+                await service.refresh();
                 const value = await handler(raw);
                 return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
             }
@@ -123,7 +128,7 @@ function createMcpServer(service) {
         occurrence_at: z.string().min(1).optional(),
         snooze_minutes: z.number().int().min(1).max(1440).optional()
     }).refine(value => value.action === 'snooze' || value.snooze_minutes === undefined, { message: 'snooze_minutes is only valid for the snooze action.' }), ({ action, alarm_id, occurrence_at, snooze_minutes }) => service.alarmControl({ action, alarmId: alarm_id, occurrenceAt: occurrence_at, snoozeMinutes: snooze_minutes }));
-    tool('radio_airplay_list', 'Discover AirPlay receivers visible to this Mac. Returns opaque receiver IDs; always call this before selecting a receiver.', undefined, async () => (await service.listAirPlayDevices()).map(device => ({
+    tool('radio_airplay_list', 'Discover AirPlay receivers visible to this device. Returns opaque receiver IDs; always call this before selecting a receiver.', undefined, async () => (await service.listAirPlayDevices()).map(device => ({
         id: device.id,
         name: device.name,
         host: device.host,
@@ -133,7 +138,7 @@ function createMcpServer(service) {
         local: device.local ?? false
     })));
     tool('radio_airplay_select', 'Switch current or future interactive playback to an exact AirPlay receiver ID returned by radio_airplay_list. Opens RadioCLI when needed unless open_ui=false.', z.object({ device_id: z.string().min(1), open_ui: z.boolean().optional() }), ({ device_id, open_ui }) => service.selectAirPlayDevice(device_id, open_ui));
-    tool('radio_airplay_use_local', 'Switch interactive playback from AirPlay back to this Mac using the best available local backend.', z.object({ open_ui: z.boolean().optional() }).optional(), args => service.useLocalOutput(args?.open_ui));
+    tool('radio_airplay_use_local', 'Switch interactive playback from AirPlay back to this device using the best available local backend.', z.object({ open_ui: z.boolean().optional() }).optional(), args => service.useLocalOutput(args?.open_ui));
     tool('radio_airplay_submit_code', 'Submit a receiver-displayed AirPlay code to the active AirPlay session. Use only a code the user explicitly provides; RadioCLI never saves it.', z.object({ code: z.string().min(1).max(64) }), ({ code }) => service.submitAirPlayPasscode(code));
     return server;
 }

package/dist/agent/service.js

@@ -1,12 +1,16 @@
 import { randomInt } from 'node:crypto';
 import { defaultAgentControlSettings, themeNames, receiverStyleNames } from '../types.js';
+import { LibraryRepository } from '../storage/repository.js';
 import { JsonLibraryStore, stationKey } from '../storage/store.js';
+import { parseRadioCommand } from './command-schema.js';
+import { matchesStationId } from '../storage/station-identity.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 { airPlayPolicy } from '../player/airplay-policy.js';
 import { detectPlaybackBackends } from '../player/backend-install.js';
 import { AgentAlarmService } from './alarm-service.js';
 import { appVersion } from '../version.js';
@@ -15,22 +19,29 @@ export class AgentRadioService {
     runtime;
     store;
     providers;
+    source;
     stationCache = new Map();
     alarms;
-    constructor(runtime, store = new JsonLibraryStore(), providers = new ProviderManager()) {
+    constructor(runtime, store = new JsonLibraryStore(), providers = new ProviderManager(), 
+    // Local shell commands do not enable or register agent/MCP integrations.
+    source = 'agent') {
         this.runtime = runtime;
         this.store = store;
         this.providers = providers;
+        this.source = source;
         this.alarms = new AgentAlarmService(this.store, id => this.resolveStationId(id), undefined, status => this.handoffAlarm(status));
     }
-    settings() { return this.store.snapshot().settings; }
+    async refresh() { if (this.store instanceof LibraryRepository)
+        await this.store.readFresh(); }
+    settings() { return this.store.settings(); }
+    connect() { return connectRadioSession(undefined, { source: this.source }); }
     appearance() {
         this.assertEnabled();
         return { themes: themeNames, receiverStyles: receiverStyleNames, current: this.settings() };
     }
     async status() {
         this.assertEnabled();
-        const client = await connectRadioSession();
+        const client = await this.connect();
         const state = this.store.snapshot();
         return {
             connected: Boolean(client),
@@ -106,21 +117,27 @@ export class AgentRadioService {
             : 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.playStation(station, queue, input);
+    }
+    async playStation(station, queue = [station], options = {}) {
+        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 ordered = queue.some(item => stationKey(item) === stationKey(station)) ? queue : [station, ...queue];
         return this.send({
             type: 'play',
             station,
             queue: ordered,
-            openNowPlaying: this.agentSettings().focusNowPlaying,
-            ifPlaying: input.ifPlaying ?? 'replace'
-        }, input.openUi);
+            openNowPlaying: this.source === 'agent' && this.agentSettings().focusNowPlaying,
+            ifPlaying: options.ifPlaying ?? 'replace'
+        }, options.openUi);
     }
     async control(command, openUi) {
         this.assertEnabled();
-        const client = await connectRadioSession();
+        const client = await this.connect();
         if (!client && command.type === 'set-volume') {
             const volume = Math.min(100, Math.max(0, command.volume));
-            this.store.updateSettings({ volume });
+            await 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)) {
@@ -132,17 +149,24 @@ export class AgentRadioService {
     }
     async setFavorite(favorite, stationId) {
         this.assertEnabled();
-        const client = await connectRadioSession();
+        const client = await this.connect();
         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.');
+        return this.favoriteStation(station, favorite);
+    }
+    async favoriteStation(station, favorite) {
+        this.assertEnabled();
+        const client = await this.connect();
+        if (client)
+            return client.call({ type: 'set-favorite', favorite, station });
         const isFavorite = this.store.isFavorite(station);
         if (isFavorite !== favorite)
-            this.store.toggleFavorite(station);
+            await this.store.toggleFavorite(station);
         if (favorite && !isFavorite && this.store.snapshot().settings.shareDirectoryVotes)
-            void this.providers.vote(station);
+            void this.providers.vote(station).catch(() => undefined);
         return { ok: true, message: `${favorite ? 'Favorited' : 'Removed favorite'}: ${station.name}`, station };
     }
     async updateAppearance(input) {
@@ -151,10 +175,10 @@ export class AgentRadioService {
             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();
+        const client = await this.connect();
         if (client)
             return client.call({ type: 'update-settings', settings: input });
-        return this.store.updateSettings(input).settings;
+        return (await this.store.updateSettings(input)).settings;
     }
     async runCompletionPreset() {
         const preset = this.agentSettings().completionPreset;
@@ -162,7 +186,7 @@ export class AgentRadioService {
             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) {
+    async configureCompletionPreset(input) {
         this.assertEnabled();
         const agentControl = this.agentSettings();
         const completionPreset = { ...agentControl.completionPreset, ...input };
@@ -170,15 +194,15 @@ export class AgentRadioService {
             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;
+        return (await this.store.updateSettings({ agentControl: { ...agentControl, completionPreset } })).settings.agentControl;
     }
     async updateAgentPreferences(input) {
         this.assertEnabled();
         const agentControl = { ...this.agentSettings(), ...input };
-        const client = await connectRadioSession();
+        const client = await this.connect();
         if (client)
             return client.call({ type: 'update-settings', settings: { agentControl } });
-        return this.store.updateSettings({ agentControl }).settings.agentControl;
+        return (await this.store.updateSettings({ agentControl })).settings.agentControl;
     }
     alarmList() { this.assertEnabled(); return this.alarms.list(); }
     alarmStatus() { this.assertEnabled(); return this.alarms.status(); }
@@ -191,13 +215,17 @@ export class AgentRadioService {
     async listAirPlayDevices() {
         this.assertEnabled();
         this.assertAirPlayPlatform();
-        const client = await connectRadioSession();
-        if (client)
-            return (await client.call({ type: 'airplay-list' })).data ?? [];
+        const client = await this.connect();
+        if (client) {
+            const result = await client.call({ type: 'airplay-list' });
+            if (!result.ok)
+                throw new Error(result.message);
+            return result.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.');
+            throw new Error('AirPlay is unavailable on this device. Run radiocli doctor to check FFmpeg, discovery, and the optional sender.');
         return player.refreshAirPlayDevices();
     }
     async selectAirPlayDevice(deviceId, openUi) {
@@ -209,17 +237,17 @@ export class AgentRadioService {
             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 });
+        await 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();
+        const client = await this.connect();
         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 });
+            await this.store.updateSettings({ preferredBackend: backend });
             return idleResult(`Audio output set to this device (${backend}).`);
         }
         return this.send({ type: 'airplay-local' }, openUi);
@@ -227,7 +255,7 @@ export class AgentRadioService {
     async submitAirPlayPasscode(code) {
         this.assertEnabled();
         this.assertAirPlayPlatform();
-        const client = await connectRadioSession();
+        const client = await this.connect();
         if (!client)
             throw new Error('No active AirPlay session is waiting for a receiver code.');
         return client.call({ type: 'airplay-passcode', code });
@@ -252,19 +280,18 @@ export class AgentRadioService {
     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();
+        this.assertEnabled();
+        let client = await this.connect();
         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;
+            const shouldOpen = openUi ?? (this.source === 'agent' && 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);
-            });
+            }, undefined, { source: this.source });
         }
         return client.call(command);
     }
@@ -290,8 +317,10 @@ export class AgentRadioService {
     }
     async findStation(id, candidates) {
         const normalized = id.trim();
-        const local = this.stationCache.get(normalized)
-            ?? candidates.find(station => opaqueStationId(station) === normalized || station.id === normalized);
+        const matches = new Map(candidates.filter(station => matchesStationId(station, normalized)).map(station => [stationKey(station), station]));
+        if (matches.size > 1)
+            throw new Error('This legacy station ID is ambiguous. Search or browse again and use the current station ID.');
+        const local = this.stationCache.get(normalized) ?? [...matches.values()][0];
         if (local)
             return local;
         const separator = normalized.indexOf(':');
@@ -305,20 +334,26 @@ export class AgentRadioService {
         return station ?? undefined;
     }
     remember(stations) {
-        for (const station of stations)
-            this.stationCache.set(opaqueStationId(station), station);
+        for (const station of stations) {
+            const key = opaqueStationId(station);
+            this.stationCache.delete(key);
+            this.stationCache.set(key, station);
+        }
+        while (this.stationCache.size > 1024)
+            this.stationCache.delete(this.stationCache.keys().next().value);
         return stations;
     }
     agentSettings() {
         return this.settings().agentControl ?? defaultAgentControlSettings;
     }
     assertEnabled() {
-        if (!this.agentSettings().enabled)
+        if (this.source === 'agent' && !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.');
+        const policy = airPlayPolicy(this.settings());
+        if (!policy.enabled)
+            throw new Error(policy.message);
     }
 }
 function opaqueStationId(station) { return `${station.provider}:${station.id}`; }
@@ -337,7 +372,7 @@ export function stationForAgent(station) {
     };
 }
 function encodeAgentCommand(command) { return Buffer.from(JSON.stringify(command)).toString('base64url'); }
-export function decodeAgentCommand(value) { return JSON.parse(Buffer.from(value, 'base64url').toString('utf8')); }
+export function decodeAgentCommand(value) { return parseRadioCommand(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 } } };