@ciphore/radiocli 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -5,7 +5,137 @@ All notable changes to RadioCLI are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.2.3] - 2026-09-07
+
+### Added
+
+- Added opt-in local coding-agent control through both a typed stdio MCP server
+  and `radiocli agent` shell commands, covering discovery, playback, favorites,
+  listening stats, appearance, and configurable task-completion actions.
+- Added automatic MCP setup for detected Codex, Claude Code, OpenCode, Cursor,
+  Gemini CLI, VS Code/Copilot Agent Host, and Orca-backed runtimes, plus a
+  portable configuration for other MCP clients.
+- Added typed MCP and voice-accessible alarm management, active ringing
+  controls, and macOS AirPlay discovery, receiver selection, local-output
+  switching, and ephemeral passcode submission.
+- Added `radiocli update --install`, package-manager-aware upgrade commands,
+  an in-app update indicator, read-only MCP update status, and
+  `radiocli mcp repair`.
+- Added Agent settings for installing or repairing MCP integrations and choosing
+  between a visible terminal player and headless playback.
+- Added the animated Gallop receiver as the new default and a color-field
+  Crossfade receiver.
+
+### Fixed
+
+- Agent playback continues to open the terminal TUI by default on every platform,
+  while interactive setup now explains the macOS Automation prompt and offers an
+  explicit headless opt-out. MCP guidance prevents ordinary task-completion radio
+  actions from creating implicit goals or monitors.
+- MCP registrations now use upgrade-stable, directly executable launchers,
+  including a shell-free Node command on Windows, and enabled registrations are
+  repaired after an in-app or CLI update.
+- Active interactive or agent playback now yields cleanly when an alarm begins,
+  preventing overlapping streams while preserving the alarm if TUI handoff fails.
+- Kept the Countries station-count column fixed while scrolling, added focused
+  marquee reading for overlong country and station names across Explore,
+  Library, and Nearby, and aligned Overview descriptions behind a compact
+  separator-free title column.
+
+### Security
+
+- Agent playback uses a single-owner, authenticated loopback session with
+  serialized commands, private discovery files, and strict isolation from
+  active alarm sessions. Agent tools accept saved or RadioCLI-discovered station
+  IDs rather than arbitrary stream URLs.
+- Alarm removal requires an exact ID and explicit confirmation. AirPlay receiver
+  IDs must come from local discovery, and receiver passcodes are never persisted
+  or echoed by agent responses.
+
+## [0.2.2] - 2026-09-04
+
+### Added
+
+- Added one-time and IANA-timezone recurring radio alarms under Overview, with a
+  full-screen TUI editor, station picker, next-run preview, enable/disable,
+  delete confirmation, test tune, repair, and active ringing controls.
+- Added native background registration through macOS launchd, Windows Task
+  Scheduler, and systemd user timers on Linux, plus `radiocli alarm` commands
+  for scripting, inspection, health checks, synchronization, and playback
+  control.
+- Added optional per-alarm wake requests where the OS supports them and a
+  separate cross-platform Alarm Guard that prevents idle sleep until the next
+  occurrence.
+- Added automatic ringing-control launch in the terminal captured when an alarm
+  is synchronized, with reuse of an already-running RadioCLI TUI.
+- Added a navigable **Verify alarm setup** rehearsal that exercises a disposable
+  native job, the saved terminal, authenticated controls, sleep protection,
+  system volume, and a three-second configured-station sample before cleanup.
+- Added `radiocli setup`, an interactive installer that detects supported
+  package managers, previews required playback tools, supports dry runs, guides
+  installation, and verifies the resulting local playback configuration.
+- Added an adaptive Explore experience with a responsive Cosmo world map,
+  height-aware station lists in micro terminals, pointer-accurate map
+  selection, and safe scrolling marquees for long station details.
+- Added richer `radiocli doctor` playback diagnostics, including the resolved
+  mpv path, discovery source, launchability, version output, and actionable
+  launch errors. Windows discovery now covers package-manager shims, common
+  application directories, and registered mpv installations.
+
+### Changed
+
+- Full library backup and restore now carries alarm definitions and latest run outcomes;
+  native jobs, Alarm Guard state, runtime health, and local control credentials
+  remain specific to each machine and are rebuilt by alarm synchronization.
+- macOS terminal Automation permission is requested during alarm setup, and a
+  TUI opened by a ringing alarm now protects the active native job from startup,
+  repair, edit, and delete reconciliation until playback ends.
+- Snooze now closes the completed ringing session, returns to Alarms, and shows
+  the next ring time. Alarm playback temporarily unmutes and raises a low local
+  system output to the configured alarm level on macOS, Windows, and supported
+  Linux audio stacks, restoring the previous state afterward.
+- Alarm list and editor presentation is more concise: historical dismissal text,
+  duplicated controls, and long scheduler caveats were removed; specific field
+  guidance is now inline and Save is presented as a display-color action.
+- Alarm ringing controls now use Enter to transfer the station into normal
+  interactive playback and Space to stop and snooze for ten minutes. The alarm
+  UI and documentation identify scheduling as experimental beta functionality,
+  explain when the terminal may close, and recommend a secondary device for
+  critical wake-ups.
+- Playback-backend guidance now directs users to `radiocli setup` when local
+  tools are missing, with updated CLI help, setup documentation, and status
+  messages covering the guided workflow.
+- Receiver animation updates are isolated from the rest of the application,
+  respect reduced-motion preferences, and use cached visualizer geometry and
+  compact color runs to reduce rendering work without changing visual output.
+- Radio Browser requests now use atlas-aware timeouts and retain clearer
+  provider failure details when station directories are slow or unavailable.
+
+### Fixed
+
+- Alarm lists now scroll long text only on the focused interactive row, keep
+  selection and enabled-state markers fixed, and avoid repeating station and
+  next-run details. Compact and micro layouts use shorter next-wake, scheduler,
+  and beta-safety messages instead of clipping desktop-length copy.
+- Footer shortcut legends now balance actions across every available row,
+  reserve an additional row in compact terminals when space permits, and show
+  concise key-only hints in micro layouts instead of ending in truncated text.
+  The version and update indicator remains independently anchored at bottom right.
+- Rapid keyboard and mouse-wheel navigation now commits the selected row
+  immediately, cancels pending automatic station skips, and preserves alarm
+  editor scrolling; search input keeps ownership of typed alarm-shortcut
+  characters.
+- Player shutdown now coalesces concurrent stop requests, while delayed
+  automatic skipping can be canceled during retuning to avoid duplicate
+  process termination and unintended station changes.
+- Explore maps, station lists, and screen rendering now remain aligned and
+  navigable across compact and true-micro terminal sizes, with improved map
+  centering, cursor mapping, and visible provider errors.
+
+### Security
+
+- Active alarm controls and Alarm Guard ownership checks use authenticated
+  loopback-only endpoints with machine-local private token files.
 
 ## [0.2.1] - 2026-08-22
 
@@ -265,6 +395,8 @@ Initial public release.
 [0.1.9]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.9
 [0.2.0]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.2.0
 [0.2.1]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.2.1
+[0.2.2]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.2.2
+[0.2.3]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.2.3
 [0.1.4]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.4
 [0.1.3]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.3
 [0.1.2]: https://github.com/Ciphore/RadioCLI/releases/tag/v0.1.2

package/README.md

@@ -18,9 +18,11 @@ Built with [Ink](https://github.com/vadimdemedes/ink),
 - Discover stations through Explore, Search, Countries, or approximate-location Nearby.
 - Listen with a receiver-style Now Playing screen, live metadata, sleep timer, diagnostics, and selectable visualizers.
 - Keep favorites, recents, imports, track history, and listening stats on your machine.
+- Create one-time or recurring radio alarms from the TUI, with native background
+  scheduling, station fallback, missed-run grace, snooze, and optional Alarm Guard.
 - Move through the exact station list you tuned from with previous and next controls.
 - Use `mpv` for complete playback control, with `ffplay` and VLC as limited fallbacks.
-- Resize freely: full, compact, and micro layouts preserve navigation and essential controls.
+- Resize freely: full, compact, and micro layouts preserve navigation and essential controls; Explore retains its interactive world map at every usable size.
 
 ## Quick start
 
@@ -35,13 +37,14 @@ macOS, Linux, or Windows with npm:
 
 ```bash
 npm install -g @ciphore/radiocli
-radiocli doctor
+radiocli setup
 radiocli
 ```
 
 RadioCLI requires Node.js 22 or newer. The Homebrew formula installs `mpv` and
-FFmpeg; npm installs JavaScript dependencies only, so install `mpv` with your
-system package manager for pause, volume, mute, media keys, and metadata.
+FFmpeg. After an npm install, `radiocli setup` detects the operating system and
+package manager, lets you choose `mpv`, FFmpeg, and VLC, installs the selected
+native tools with branded progress feedback, and verifies playback readiness.
 
 See the [installation guide](apps/docs/content/docs/getting-started/install.mdx)
 for Windows, Linux distributions, AirPlay prerequisites, and fallback players.
@@ -91,6 +94,24 @@ covers filters, playback, media-key learning, AirPlay, and every command.
 
 ## CLI
 
+RadioCLI can also be controlled by local coding agents. Run `radiocli setup`
+and opt into MCP, or use `radiocli setup --mcp`, to configure detected Codex,
+Claude, OpenCode, Cursor, Gemini, VS Code/Copilot, and Orca-backed runtimes
+automatically. From the TUI, open **Settings → Agent control & MCP** and turn on
+**Allow local agent control** for the same one-step setup—no terminal command is
+required. The same actions are
+available to non-MCP harnesses through `radiocli agent` and `radiocli alarm`:
+search and play stations, browse recents/favorites/nearby stations, favorite the
+current station, inspect listening stats, create and control alarms, control
+macOS AirPlay, change the receiver look, or run a user-configured completion
+preset. Codex Voice can invoke those same typed MCP tools. Agent playback opens
+the normal RadioCLI TUI in a terminal window by default on macOS, Windows, and
+Linux. Interactive setup explains that macOS may require the agent host to approve
+a one-time Automation prompt; users can explicitly opt into headless playback.
+Scheduled alarms remain isolated and always use local output rather than
+unattended AirPlay. See the
+[CLI guide](apps/docs/content/docs/getting-started/cli.mdx#local-agent-and-mcp-control).
+
 ```bash
 radiocli                 # Start the TUI
 radiocli check           # Check providers, playback tools, and the local store
@@ -100,11 +121,46 @@ radiocli countries
 radiocli import stations.m3u
 radiocli export favorites.m3u
 radiocli add-url <stream-url> [station name]
+radiocli alarm list
+radiocli alarm doctor
+radiocli update --install # Upgrade and repair enabled MCP registrations
 ```
 
+Existing installations keep their library and preferences when upgraded. Use
+`radiocli update` to inspect the detected Homebrew, npm, pnpm, or Bun command,
+or `radiocli update --install` to run it. MCP registrations use an
+upgrade-stable launcher so versioned package paths do not break them. On
+Windows this is a shell-free Node command; on Unix it uses the `radiocli` shim.
+Run `radiocli mcp status` to inspect registrations and `radiocli mcp repair`
+after moving an installation or when an agent client reports a stale server;
+fully quit and reopen agent clients after enabling, repairing, or upgrading.
+Until that restart, even a newly created task in an already-running client will
+not have RadioCLI's tools and may incorrectly fall back to browser playback.
+
 RadioCLI imports `.m3u`, `.pls`, and `.xspf` playlists. It exports favorites
 and imported streams as `.m3u`.
 
+Alarms are experimental beta functionality and live under **Overview**,
+immediately before Settings. Saving an enabled
+alarm registers it with launchd on macOS, a systemd user timer on Linux, or Task
+Scheduler on Windows, so the terminal does not need to remain open. When it
+fires, RadioCLI reopens the saved supported terminal and shows the ringing
+screen. Enter transfers the station into normal interactive playback; Space
+stops it and snoozes for 10 minutes. If a
+RadioCLI TUI is already open, that instance shows the controls instead. The
+computer must still be powered on with a logged-in interactive audio session; wake timing
+depends on hardware and OS power policy. See the [CLI guide](apps/docs/content/docs/getting-started/cli.mdx)
+and [reliability notes](apps/docs/content/docs/reliability.mdx) before relying on
+an alarm for something critical. Use a secondary device as the primary alarm
+for safety-critical, medical, travel, or emergency timing. See the dedicated
+[Alarms guide](apps/docs/content/docs/alarms.mdx) for the full workflow.
+
+The **Verify alarm setup** row performs a disposable native-scheduler
+registration, an authenticated terminal/control handshake, sleep-inhibitor and
+system-volume checks, and a short sample from the next configured alarm. It
+cleans up the temporary job and reports hard blockers separately from hardware-
+or policy-dependent wake limitations.
+
 See the [CLI guide](apps/docs/content/docs/getting-started/cli.mdx) for all
 arguments and examples.
 
@@ -120,14 +176,27 @@ Playback waits for backend readiness, applies tune timeouts, and can skip broken
 streams. Corrupt library and cache files are backed up instead of silently
 overwritten.
 
+Scheduled playback retries the primary station once, then tries an optional
+fallback. A missed-run grace window controls catch-up after sleep or logout.
+True fade-in requires `mpv`; `ffplay` and VLC start audibly at the configured
+target volume. Scheduled alarms always use local speakers, never unattended
+AirPlay.
+
+On macOS, an npm or source installation is executed by Node, so System Settings
+may identify its background item as `node`. Showing RadioCLI as the providing
+application requires a future signed macOS app bundle with a bundled helper;
+changing a launchd label cannot safely relabel the executable.
+
 Read the [reliability notes](apps/docs/content/docs/reliability.mdx) for failure
 handling and troubleshooting.
 
 ## Privacy
 
 RadioCLI does not require an account, proxy audio, or upload your listening
-history. Favorites, recents, imports, settings, track history, and activity stay
-in a local JSON library.
+history. Favorites, recents, imports, settings, alarms, track history, and
+activity stay in a local JSON library. Full JSON library backups include alarm
+definitions, while native scheduler registrations, runtime health, Alarm Guard
+state, and authenticated loopback-control tokens remain machine-local.
 
 Nearby contacts `ipapi.co` only when you open that screen, then uses an
 approximate location to sort the local station atlas. Disable the lookup with
@@ -145,6 +214,7 @@ complete data-flow description.
 - `src/ui` — screens, input, layout, and terminal rendering
 - `src/providers` — station directories, resolution, and caches
 - `src/player` — playback backends, metadata, and AirPlay
+- `src/alarms` — schedules, native registration, Alarm Guard, and active controls
 - `src/storage` — local library persistence and migration
 - `apps/docs` — documentation website and manual
 

package/dist/agent/alarm-service.js

@@ -0,0 +1,210 @@
+import { canonicalizeAlarmTime, canonicalizeIsoWeekdays, canonicalizeTimeZone, nextOccurrenceForAlarm } from '../alarms/schedule.js';
+import { connectActiveAlarms } from '../alarms/active-session.js';
+import { createSchedulerService } from '../alarms/scheduler.js';
+export class AgentAlarmService {
+    store;
+    resolveStation;
+    scheduler;
+    handoffToInteractive;
+    constructor(store, resolveStation, scheduler = createSchedulerService(), handoffToInteractive) {
+        this.store = store;
+        this.resolveStation = resolveStation;
+        this.scheduler = scheduler;
+        this.handoffToInteractive = handoffToInteractive;
+    }
+    async list() {
+        return Promise.all(this.store.listAlarms().map(alarm => this.describe(alarm)));
+    }
+    async status() {
+        const alarms = this.store.listAlarms();
+        return {
+            active: await this.activeStatuses(),
+            scheduler: await this.scheduler.runtimeStatus(alarms),
+            alarms: await Promise.all(alarms.map(alarm => this.describe(alarm)))
+        };
+    }
+    async create(input) {
+        const station = await this.requiredStation(input.stationId);
+        const fallbackStation = input.fallbackStationId
+            ? await this.requiredStation(input.fallbackStationId)
+            : undefined;
+        const alarmInput = {
+            label: cleanLabel(input.label ?? station.name),
+            enabled: input.enabled ?? true,
+            station,
+            schedule: normalizeSchedule(input.schedule),
+            playback: {
+                volume: boundedInteger(input.volume ?? 40, 'volume', 0, 100),
+                fadeSeconds: boundedInteger(input.fadeSeconds ?? 0, 'fadeSeconds', 0, 3600),
+                stopAfterMinutes: boundedInteger(input.stopAfterMinutes ?? 60, 'stopAfterMinutes', 1, 10080),
+                ...(fallbackStation ? { fallbackStation } : {})
+            },
+            reliability: {
+                missedRunGraceMinutes: boundedInteger(input.missedRunGraceMinutes ?? 10, 'missedRunGraceMinutes', 0, 10080),
+                wakeIfSupported: input.wakeIfSupported ?? false,
+                keepAwakeUntilAlarm: input.keepAwakeUntilAlarm ?? false
+            }
+        };
+        const alarm = this.store.addAlarm(alarmInput);
+        await this.syncSaved(alarm);
+        return this.describe(alarm);
+    }
+    async update(id, input) {
+        const alarm = this.requiredAlarm(id);
+        const station = input.stationId ? await this.requiredStation(input.stationId) : alarm.station;
+        const fallbackStation = input.clearFallback
+            ? undefined
+            : input.fallbackStationId ? await this.requiredStation(input.fallbackStationId) : alarm.playback.fallbackStation;
+        const updated = this.store.updateAlarm(alarm.id, {
+            label: input.label === undefined ? alarm.label : cleanLabel(input.label),
+            enabled: input.enabled ?? alarm.enabled,
+            station,
+            schedule: input.schedule ? normalizeSchedule(input.schedule) : alarm.schedule,
+            playback: {
+                volume: boundedInteger(input.volume ?? alarm.playback.volume, 'volume', 0, 100),
+                fadeSeconds: boundedInteger(input.fadeSeconds ?? alarm.playback.fadeSeconds, 'fadeSeconds', 0, 3600),
+                stopAfterMinutes: boundedInteger(input.stopAfterMinutes ?? alarm.playback.stopAfterMinutes, 'stopAfterMinutes', 1, 10080),
+                ...(fallbackStation ? { fallbackStation } : {})
+            },
+            reliability: {
+                missedRunGraceMinutes: boundedInteger(input.missedRunGraceMinutes ?? alarm.reliability.missedRunGraceMinutes, 'missedRunGraceMinutes', 0, 10080),
+                wakeIfSupported: input.wakeIfSupported ?? alarm.reliability.wakeIfSupported,
+                keepAwakeUntilAlarm: input.keepAwakeUntilAlarm ?? alarm.reliability.keepAwakeUntilAlarm
+            }
+        });
+        await this.syncSaved(updated);
+        return this.describe(updated);
+    }
+    async setEnabled(id, enabled) {
+        const alarm = this.store.toggleAlarm(this.requiredAlarm(id).id, enabled);
+        await this.syncSaved(alarm);
+        return this.describe(alarm);
+    }
+    async remove(id, confirm) {
+        if (!confirm)
+            throw new Error('Alarm removal requires confirm=true. List alarms first and confirm the exact alarm ID with the user.');
+        const alarm = this.requiredAlarm(id);
+        await this.scheduler.remove(alarm.id);
+        if (!this.store.removeAlarm(alarm.id))
+            throw new Error(`Alarm not found: ${id}`);
+        return { ok: true, removed: alarm.id };
+    }
+    async sync() {
+        return this.scheduler.syncAll(this.store.listAlarms());
+    }
+    async controlActive(input) {
+        const { client, status } = await this.selectActive(input.alarmId, input.occurrenceAt);
+        if (input.action === 'dismiss')
+            await client.dismiss();
+        else if (input.action === 'keep-playing')
+            await client.keepPlaying();
+        else if (input.action === 'handoff') {
+            if (status.state !== 'playing')
+                throw new Error('Alarm playback is still starting.');
+            if (!this.handoffToInteractive)
+                throw new Error('Interactive playback handoff is unavailable.');
+            await this.handoffToInteractive(status);
+            await client.handoff();
+        }
+        else
+            await client.snooze(boundedInteger(input.snoozeMinutes ?? 10, 'snoozeMinutes', 1, 1440));
+        return { ok: true, action: input.action, alarm: activeStatusForAgent(status) };
+    }
+    async describe(alarm) {
+        return {
+            id: alarm.id,
+            label: alarm.label,
+            enabled: alarm.enabled,
+            station: { id: `${alarm.station.provider}:${alarm.station.id}`, name: alarm.station.name },
+            schedule: alarm.schedule,
+            nextOccurrence: nextOccurrenceForAlarm(alarm, new Date())?.toISOString() ?? null,
+            playback: {
+                volume: alarm.playback.volume,
+                fadeSeconds: alarm.playback.fadeSeconds,
+                stopAfterMinutes: alarm.playback.stopAfterMinutes,
+                ...(alarm.playback.fallbackStation ? { fallbackStation: {
+                        id: `${alarm.playback.fallbackStation.provider}:${alarm.playback.fallbackStation.id}`,
+                        name: alarm.playback.fallbackStation.name
+                    } } : {})
+            },
+            reliability: alarm.reliability,
+            lastRun: alarm.lastRun,
+            snoozedUntil: alarm.nextOverride?.at
+        };
+    }
+    async activeStatuses() {
+        return (await Promise.all((await connectActiveAlarms()).map(client => client.status()))).map(activeStatusForAgent);
+    }
+    async selectActive(alarmId, occurrenceAt) {
+        const matches = [];
+        for (const client of await connectActiveAlarms()) {
+            const status = await client.status();
+            if ((!alarmId || status.alarmId === alarmId) && (!occurrenceAt || status.scheduledAt === occurrenceAt))
+                matches.push({ client, status });
+        }
+        if (!matches.length)
+            throw new Error('No matching alarm is currently ringing.');
+        if (matches.length > 1)
+            throw new Error('Multiple alarms are ringing. List alarm status, then provide alarm_id and optionally occurrence_at.');
+        return matches[0];
+    }
+    requiredAlarm(id) {
+        const alarm = this.store.getAlarm(id);
+        if (!alarm)
+            throw new Error(`Alarm not found: ${id}`);
+        return alarm;
+    }
+    async requiredStation(id) {
+        const station = await this.resolveStation(id);
+        if (!station)
+            throw new Error(`Unknown station ID: ${id}. Search or browse first.`);
+        return station;
+    }
+    async syncSaved(alarm) {
+        try {
+            await this.scheduler.sync(alarm);
+        }
+        catch (error) {
+            throw new Error(`Alarm ${alarm.id} was saved, but scheduler setup is degraded: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+function normalizeSchedule(schedule) {
+    if (schedule.type === 'once') {
+        const instant = new Date(schedule.at);
+        if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(schedule.at) || !Number.isFinite(instant.getTime()) || instant.getUTCSeconds() !== 0 || instant.getUTCMilliseconds() !== 0) {
+            throw new Error('One-time alarms require an absolute ISO-8601 minute with an offset or Z and zero seconds.');
+        }
+        if (instant.getTime() <= Date.now())
+            throw new Error('One-time alarms must be scheduled in the future.');
+        return { type: 'once', at: instant.toISOString() };
+    }
+    return {
+        type: 'recurring',
+        time: canonicalizeAlarmTime(schedule.time),
+        weekdays: canonicalizeIsoWeekdays(schedule.weekdays),
+        timezone: canonicalizeTimeZone(schedule.timezone)
+    };
+}
+function boundedInteger(value, label, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max)
+        throw new Error(`${label} must be an integer from ${min} to ${max}.`);
+    return value;
+}
+function cleanLabel(value) {
+    const label = value.trim();
+    if (!label || label.length > 120 || /[\u0000-\u001F\u007F-\u009F]/.test(label))
+        throw new Error('Alarm label must be 1-120 printable characters.');
+    return label;
+}
+function activeStatusForAgent(status) {
+    return {
+        alarmId: status.alarmId,
+        scheduledAt: status.scheduledAt,
+        stationName: status.stationName,
+        ...(status.station ? { station: { id: `${status.station.provider}:${status.station.id}`, name: status.station.name } } : {}),
+        startedAt: status.startedAt,
+        state: status.state,
+        keepPlaying: status.keepPlaying
+    };
+}