@ciphore/radiocli 0.2.2 → 0.2.3

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.';
+    }
+}

package/dist/alarms/cli.js

@@ -14,6 +14,7 @@ import { AlarmPowerGuardStore } from './power-guard-store.js';
 import { openAlarmControls } from './terminal-launcher.js';
 import { hasLiveTui } from './tui-presence.js';
 import { createSystemVolumeController } from './system-volume.js';
+import { connectRadioSession } from '../agent/session.js';
 export async function runAlarmCommand(args, dependencies = {}) {
     const store = dependencies.store ?? new JsonLibraryStore();
     const scheduler = dependencies.scheduler ?? createSchedulerService();
@@ -173,7 +174,9 @@ export async function runAlarmCommand(args, dependencies = {}) {
     }
     throw new Error(alarmUsage());
 }
-function createRuntimeDeps(store, scheduler, alarmId) { const providers = new ProviderManager(); const alarm = store.getAlarm(alarmId); const detected = detectPlaybackBackends(); const settings = alarm ? alarmRuntimeSettings(store.snapshot().settings, alarm, detected) : { ...store.snapshot().settings, preferredBackend: 'auto', preferredAirPlayDevice: undefined }; const player = new PlayerController(() => settings); player.refreshDetectedBackends(); const cliPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'cli.js'); return { now: () => new Date(), store, providers, player, scheduler, inhibitor: createPowerInhibitor(), systemVolume: createSystemVolumeController(), acquireLock: acquireOccurrenceLock, createSession: defaultRunnerUtilities.createSession, openControls: () => openAlarmControls({ nodePath: process.execPath, cliPath, hasLiveTui }), wait: defaultRunnerUtilities.wait, subscribeSignals: defaultRunnerUtilities.subscribeSignals, health: scheduler.health }; }
+function createRuntimeDeps(store, scheduler, alarmId) { const providers = new ProviderManager(); const alarm = store.getAlarm(alarmId); const detected = detectPlaybackBackends(); const settings = alarm ? alarmRuntimeSettings(store.snapshot().settings, alarm, detected) : { ...store.snapshot().settings, preferredBackend: 'auto', preferredAirPlayDevice: undefined }; const player = new PlayerController(() => settings); player.refreshDetectedBackends(); const cliPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'cli.js'); return { now: () => new Date(), store, providers, player, scheduler, inhibitor: createPowerInhibitor(), systemVolume: createSystemVolumeController(), preemptInteractivePlayback: async () => { const client = await connectRadioSession(); if (!client)
+        return; const result = await client.call({ type: 'alarm-preempt' }); if (!result.ok)
+        throw new Error(result.message); }, acquireLock: acquireOccurrenceLock, createSession: defaultRunnerUtilities.createSession, openControls: () => openAlarmControls({ nodePath: process.execPath, cliPath, hasLiveTui }), wait: defaultRunnerUtilities.wait, subscribeSignals: defaultRunnerUtilities.subscribeSignals, health: scheduler.health }; }
 export function alarmRuntimeSettings(settings, alarm, backends) { const mpvFade = alarm.playback.fadeSeconds > 0 && backends.includes('mpv'); return { ...settings, volume: mpvFade ? 0 : alarm.playback.volume, preferredBackend: mpvFade ? 'mpv' : 'auto', preferredAirPlayDevice: undefined }; }
 async function testAlarm(alarm, store) {
     const scheduledAt = new Date(Math.floor(Date.now() / 60_000) * 60_000);

package/dist/alarms/runner.js

@@ -35,6 +35,10 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
     const earlySignal = new Promise(resolve => { resolveEarlySignal = resolve; });
     const unsubscribeSignals = deps.subscribeSignals?.(() => { signalReceived = true; resolveEarlySignal(); onPlaybackSignal(); void deps.player.stop().catch(() => undefined); });
     const finish = (status, message) => ({ status, scheduledAt: scheduledAt.toISOString(), ...(firedAt ? { firedAt: firedAt.toISOString() } : {}), finishedAt: deps.now().toISOString(), ...(message ? { message } : {}) });
+    let action;
+    let keepPlaying = false;
+    let resolveAction = () => { };
+    const actionPromise = new Promise(resolve => { resolveAction = resolve; });
     try {
         if (!alarm || !alarm.enabled)
             return { message: 'Alarm is missing or disabled.' };
@@ -53,6 +57,22 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
             outcome = finish('missed', 'Alarm was outside its missed-run grace window.');
             return { status: outcome.status, message: outcome.message };
         }
+        const claimingStatus = { alarmId, scheduledAt: scheduledAt.toISOString(), stationName: alarm.station.name, station: alarm.station, startedAt: deps.now().toISOString(), state: 'starting' };
+        const creatingSession = deps.createSession(claimingStatus, {
+            onDismiss: () => { action = 'dismissed'; resolveAction('dismissed'); resolveEarlySignal(); },
+            onSnooze: minutes => { deps.store.snoozeAlarm(alarmId, new Date(deps.now().getTime() + minutes * 60_000)); preserveNextOverride = true; action = 'snoozed'; resolveAction('snoozed'); resolveEarlySignal(); },
+            onKeepPlaying: () => { keepPlaying = true; session?.update({ keepPlaying: true }); },
+            onHandoff: () => { if (!listening)
+                throw new Error('Alarm playback is still starting.'); preserveSystemVolume = true; action = 'handoff'; resolveAction('handoff'); }
+        });
+        void creatingSession.then(created => { if (signalReceived)
+            void created.close().catch(() => undefined); }).catch(() => { });
+        const created = await Promise.race([creatingSession.then(value => ({ value })), earlySignal.then(() => ({ signal: true }))]);
+        if ('signal' in created) {
+            outcome = finish('dismissed', 'Alarm interrupted while local controls were starting.');
+            return { status: 'dismissed', message: outcome.message };
+        }
+        session = created.value;
         const claimed = deps.store.getAlarm(alarmId);
         if (claimed?.enabled && claimed.schedule.type === 'recurring') {
             if (deps.scheduler.syncClaimed)
@@ -60,16 +80,10 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
             else
                 await deps.scheduler.sync(claimed);
         }
-        if (deps.systemVolume)
-            try {
-                systemVolumeLease = await deps.systemVolume.acquireMinimum(alarm.playback.volume);
-                deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: true, active: true, message: systemVolumeLease.message });
-            }
-            catch (error) {
-                deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: false, message: `Alarm will use player volume, but system output could not be raised: ${errorMessage(error)}` });
-            }
         let resolvedStation = alarm.station;
         let lastError;
+        let interactivePreempted = false;
+        let outputPrepared = false;
         const candidates = [alarm.station, alarm.station, alarm.playback.fallbackStation].filter((item) => Boolean(item));
         for (const [candidateIndex, candidate] of candidates.entries()) {
             try {
@@ -78,6 +92,26 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
                     outcome = finish('dismissed', 'Alarm interrupted before playback started.');
                     return { status: 'dismissed', message: outcome.message };
                 }
+                if (!interactivePreempted) {
+                    interactivePreempted = true;
+                    try {
+                        await deps.preemptInteractivePlayback?.();
+                    }
+                    catch (error) {
+                        deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: true, message: `Alarm continued after interactive playback could not be stopped cleanly: ${errorMessage(error)}` });
+                    }
+                }
+                if (!outputPrepared) {
+                    outputPrepared = true;
+                    if (deps.systemVolume)
+                        try {
+                            systemVolumeLease = await deps.systemVolume.acquireMinimum(alarm.playback.volume);
+                            deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: true, active: true, message: systemVolumeLease.message });
+                        }
+                        catch (error) {
+                            deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: false, message: `Alarm will use player volume, but system output could not be raised: ${errorMessage(error)}` });
+                        }
+                }
                 const playPromise = deps.player.play(candidate, resolved.stream.url);
                 const tuned = await Promise.race([playPromise.then(() => ({ played: true })), earlySignal.then(() => ({ signal: true }))]);
                 if ('signal' in tuned || signalReceived) {
@@ -129,25 +163,8 @@ export async function runAlarm(alarmId, scheduledAtText, deps) {
         deps.store.addRecent(resolvedStation);
         deps.store.startListeningSession(resolvedStation, startedAt);
         listening = true;
-        let action;
-        let keepPlaying = false;
-        let resolveAction = () => { };
-        const actionPromise = new Promise(resolve => { resolveAction = resolve; });
         const activeStatus = { alarmId, scheduledAt: scheduledAt.toISOString(), stationName: resolvedStation.name, station: resolvedStation, startedAt: startedAt.toISOString(), state: 'playing' };
-        const creatingSession = deps.createSession(activeStatus, {
-            onDismiss: () => { action = 'dismissed'; resolveAction('dismissed'); },
-            onSnooze: minutes => { deps.store.snoozeAlarm(alarmId, new Date(deps.now().getTime() + minutes * 60_000)); preserveNextOverride = true; action = 'snoozed'; resolveAction('snoozed'); },
-            onKeepPlaying: () => { keepPlaying = true; session?.update({ keepPlaying: true }); },
-            onHandoff: () => { preserveSystemVolume = true; action = 'handoff'; resolveAction('handoff'); }
-        });
-        void creatingSession.then(created => { if (signalReceived)
-            void created.close().catch(() => undefined); }).catch(() => { });
-        const created = await Promise.race([creatingSession.then(value => ({ value })), earlySignal.then(() => ({ signal: true }))]);
-        if ('signal' in created) {
-            outcome = finish('dismissed', 'Alarm interrupted while local controls were starting.');
-            return { status: 'dismissed', message: outcome.message };
-        }
-        session = created.value;
+        session.update(activeStatus);
         void deps.openControls?.(activeStatus).catch(error => { try {
             deps.health?.record({ alarmId, occurrenceAt: scheduledAt.toISOString(), component: 'runner', healthy: false, active: true, message: `Alarm is playing, but RadioCLI controls could not open automatically: ${errorMessage(error)}` });
         }

package/dist/cli.js

@@ -12,12 +12,31 @@ import { resolveCommand } from './player/command.js';
 import { diagnoseCommand } from './player/command-diagnostics.js';
 import { airPlaySenderHealth } from './player/airplay-sender-health.js';
 import { appVersion } from './version.js';
-import { checkForUpdate, updateCommandForInstall } from './update-check.js';
+import { checkForUpdate, installUpdate, updateCommandForInstall } from './update-check.js';
 import { runAlarmCommand } from './alarms/cli.js';
 import { runSetup } from './setup.js';
+import { runAgentCliCommand, runMcpCommand } from './agent/cli.js';
+import { decodeAgentCommand } from './agent/service.js';
+import { runHeadlessAgentHost } from './agent/headless-host.js';
+import { configureMcpIntegrations } from './agent/mcp-install.js';
+import { defaultAgentControlSettings } from './types.js';
+const runtime = { nodePath: process.execPath, cliPath: fileURLToPath(import.meta.url) };
 if (isDirectRun(process.argv[1], import.meta.url)) {
     const args = process.argv.slice(2);
-    if (args.length > 0) {
+    if (args[0] === 'agent-ui') {
+        const encoded = args[1];
+        if (!encoded)
+            throw new Error('Missing RadioCLI agent startup request.');
+        const [{ render }, { App }] = await Promise.all([import('ink'), import('./ui/App.js')]);
+        render(_jsx(App, { initialAgentCommand: decodeAgentCommand(encoded) }), {
+            exitOnCtrlC: false,
+            kittyKeyboard: { mode: 'auto', flags: ['disambiguateEscapeCodes', 'reportEventTypes', 'reportAllKeysAsEscapeCodes'] }
+        });
+    }
+    else if (args[0] === 'agent-host') {
+        await runHeadlessAgentHost();
+    }
+    else if (args.length > 0) {
         await runCommand(args).catch(error => {
             console.error(error instanceof Error ? error.message : String(error));
             process.exitCode = 1;
@@ -49,6 +68,14 @@ export async function runCommand(args) {
         await runAlarmCommand(rest);
         return;
     }
+    if (command === 'mcp') {
+        await runMcpCommand(rest, runtime);
+        return;
+    }
+    if (command === 'agent') {
+        await runAgentCliCommand(rest, runtime);
+        return;
+    }
     if (command === 'setup') {
         if (rest.includes('--help') || rest.includes('-h')) {
             printSetupHelp();
@@ -73,6 +100,9 @@ export async function runCommand(args) {
         return;
     }
     if (command === 'update') {
+        const unknown = rest.filter(arg => arg !== '--install');
+        if (unknown.length > 0)
+            throw new Error('Usage: radiocli update [--install]');
         const updateCheck = await checkForUpdate();
         const updateCommand = updateCommandForInstall();
         if (updateCheck.error) {
@@ -84,6 +114,26 @@ export async function runCommand(args) {
             console.log(`available=${updateCheck.updateAvailable ? 'yes' : 'no'}`);
         }
         console.log(`command=${updateCommand.command}`);
+        if (rest.includes('--install')) {
+            const result = await installUpdate(updateCommand.command);
+            if (!result.ok)
+                throw new Error(`Update install failed. Run manually: ${result.command}${result.output ? `\n${result.output}` : ''}`);
+            console.log('updated=yes');
+            const agentControl = new JsonLibraryStore().snapshot().settings.agentControl ?? defaultAgentControlSettings;
+            if (agentControl.enabled) {
+                try {
+                    const repaired = await configureMcpIntegrations(true, runtime);
+                    const failed = repaired.filter(item => item.status === 'failed');
+                    console.log(`mcp_repaired=${failed.length ? 'partial' : 'yes'}`);
+                    if (failed.length)
+                        console.log(`mcp_failures=${failed.map(item => `${item.client}: ${item.detail}`).join('; ')}`);
+                }
+                catch (error) {
+                    console.log(`mcp_repaired=failed ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            console.log('restart_required=yes');
+        }
         return;
     }
     if (command === 'check') {
@@ -161,7 +211,10 @@ Usage:
   radiocli check           Show provider/backend health
   radiocli doctor [--json] Show local playback setup guidance
   radiocli setup           Install and verify native playback tools
+  radiocli mcp <command>   Install, inspect, or run the MCP integration
+  radiocli agent <command> Scriptable radio controls for local agents
   radiocli update          Show update availability and install command
+  radiocli update --install Install the latest release and repair enabled MCP entries
   radiocli countries       Print top countries
   radiocli search <query>  Search public stations
   radiocli import <file>   Import .m3u, .pls, or .xspf streams
@@ -182,7 +235,7 @@ export function isDirectRun(entryPath, moduleUrl) {
     }
 }
 function isKnownCommand(command) {
-    return ['check', 'doctor', 'setup', 'update', 'countries', 'search', 'import', 'export', 'add-url', 'alarm'].includes(command);
+    return ['check', 'doctor', 'setup', 'update', 'countries', 'search', 'import', 'export', 'add-url', 'alarm', 'mcp', 'agent'].includes(command);
 }
 function printSetupHelp() {
     console.log(`RadioCLI Setup
@@ -193,6 +246,10 @@ Usage:
   radiocli setup --all --yes             Install mpv, FFmpeg, and VLC
   radiocli setup --only mpv,ffmpeg       Select specific components
   radiocli setup --dry-run               Show commands without installing
+  radiocli setup --mcp                   Enable and configure agent MCP clients
+  radiocli setup --mcp --agent-ui        Open a terminal TUI for agent playback (default)
+  radiocli setup --mcp --headless-agent  Opt out of external terminal windows
+  radiocli setup --no-mcp                Disable and remove agent MCP entries
   radiocli setup --package-manager <pm>  Use brew, winget, scoop, choco,
                                          apt, dnf, pacman, apk, or zypper
 `);

package/dist/player/player-controller.js

@@ -230,6 +230,20 @@ export class PlayerController {
         });
         return { ok: true };
     }
+    async pause() {
+        if (this.state.state === 'paused')
+            return { ok: true };
+        if (this.state.state !== 'playing')
+            return { ok: false, message: 'RadioCLI is not currently playing.' };
+        return this.togglePause();
+    }
+    async resume() {
+        if (this.state.state === 'playing')
+            return { ok: true };
+        if (this.state.state !== 'paused')
+            return { ok: false, message: 'RadioCLI has no paused station to resume.' };
+        return this.togglePause();
+    }
     setVolume(volume) {
         const clamped = clampVolume(volume);
         const unsupported = this.unsupportedFfplayControl();
@@ -272,6 +286,11 @@ export class PlayerController {
         this.setState({ ...this.state, muted });
         return { ok: true };
     }
+    async setMuted(muted) {
+        if (this.state.muted === muted)
+            return { ok: true };
+        return this.toggleMute();
+    }
     stop() {
         if (this.stopPromise)
             return this.stopPromise;

package/dist/providers/provider-manager.js

@@ -16,6 +16,11 @@ export class ProviderManager {
     byCountry(countryCode, limit, offset) {
         return this.radioBrowser.byCountry(countryCode, limit, offset);
     }
+    byId(provider, id) {
+        if (provider !== 'radio-browser')
+            return Promise.resolve(null);
+        return this.radioBrowser.byId(id);
+    }
     nearby(location, limit) {
         return this.radioBrowser.nearby(location, limit);
     }

package/dist/providers/radio-browser.js

@@ -115,6 +115,10 @@ export class RadioBrowserProvider {
         }, { maxAgeMs: 30 * 60 * 1000 });
         return this.normalizeStations(rows);
     }
+    async byId(id) {
+        const rows = await this.request(`/json/stations/byuuid/${encodeURIComponent(id)}`, {}, { maxAgeMs: 10 * 60 * 1000 });
+        return this.normalizeStations(rows)[0] ?? null;
+    }
     async search(query, options = {}) {
         const trimmed = query.trim();
         if (!trimmed) {