@ciphore/radiocli 0.1.0

package/dist/cli.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ProviderManager } from './providers/provider-manager.js';
+import { PlayerController } from './player/player-controller.js';
+import { JsonLibraryStore } from './storage/store.js';
+import { parsePlaylistFile, stationFromUrl, writeM3u } from './playlists/playlist.js';
+import { detectPlaybackBackends, playbackBackendStatusLines } from './player/backend-install.js';
+if (isDirectRun(process.argv[1], import.meta.url)) {
+    const args = process.argv.slice(2);
+    if (args.length > 0) {
+        await runCommand(args).catch(error => {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        });
+    }
+    else {
+        const [{ render }, { App }] = await Promise.all([import('ink'), import('./ui/App.js')]);
+        render(_jsx(App, {}), {
+            exitOnCtrlC: true,
+            kittyKeyboard: {
+                mode: 'auto',
+                flags: ['disambiguateEscapeCodes', 'reportEventTypes', 'reportAllKeysAsEscapeCodes']
+            }
+        });
+    }
+}
+export async function runCommand(args) {
+    const [command, ...rest] = args;
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        printHelp();
+        return;
+    }
+    if (!isKnownCommand(command)) {
+        throw new Error(`Unknown command: ${command}\nRun radiocli help.`);
+    }
+    if (command === 'doctor') {
+        const backends = detectPlaybackBackends();
+        console.log(`backends=${backends.join(',') || 'none'}`);
+        printPlaybackBackendStatus(backends);
+        return;
+    }
+    if (command === 'check') {
+        const store = new JsonLibraryStore();
+        const providers = new ProviderManager();
+        const player = new PlayerController(() => store.snapshot().settings);
+        const backends = player.refreshDetectedBackends();
+        const health = await providers.health(store.snapshot().settings);
+        console.log(`store=${store.filePath}`);
+        console.log(`backends=${backends.join(',') || 'none'}`);
+        printPlaybackBackendStatus(backends);
+        for (const [provider, status] of Object.entries(health)) {
+            console.log(`${provider}=${status}`);
+        }
+        return;
+    }
+    if (command === 'countries') {
+        const providers = new ProviderManager();
+        const countries = await providers.countries(30);
+        for (const country of countries) {
+            console.log(`${country.code}\t${country.stationCount}\t${country.name}`);
+        }
+        return;
+    }
+    if (command === 'search') {
+        const query = rest.join(' ').trim();
+        if (!query) {
+            throw new Error('Usage: radiocli search <query>');
+        }
+        const store = new JsonLibraryStore();
+        const providers = new ProviderManager();
+        const stations = await providers.search(query, store.snapshot().settings, { limit: 20 });
+        for (const station of stations) {
+            console.log(`${station.provider}:${station.id}\t${station.name}\t${station.country ?? ''}\t${station.codec ?? ''}\t${station.bitrate ?? ''}`);
+        }
+        return;
+    }
+    if (command === 'import') {
+        const file = rest[0];
+        if (!file) {
+            throw new Error('Usage: radiocli import <playlist.m3u|playlist.pls|playlist.xspf>');
+        }
+        const stations = parsePlaylistFile(file);
+        const store = new JsonLibraryStore();
+        store.addImported(stations);
+        console.log(`imported=${stations.length}`);
+        return;
+    }
+    if (command === 'export') {
+        const file = rest[0] ?? 'radiocli-favorites.m3u';
+        const store = new JsonLibraryStore();
+        const state = store.snapshot();
+        writeM3u(file, [...state.favorites, ...state.imported]);
+        console.log(`exported=${file}`);
+        return;
+    }
+    if (command === 'add-url') {
+        const url = rest[0];
+        if (!url || !/^https?:\/\//i.test(url)) {
+            throw new Error('Usage: radiocli add-url <stream-url> [station name]');
+        }
+        const station = stationFromUrl(url, rest.slice(1).join(' ') || url);
+        const store = new JsonLibraryStore();
+        store.addImported([station]);
+        console.log(`added=${station.name}`);
+        return;
+    }
+}
+export function printHelp() {
+    console.log(`RadioCLI
+
+Usage:
+  radiocli                 Start the TUI
+  radiocli check           Show provider/backend health
+  radiocli doctor          Show local playback setup guidance
+  radiocli countries       Print top countries
+  radiocli search <query>  Search public stations
+  radiocli import <file>   Import .m3u, .pls, or .xspf streams
+  radiocli export [file]   Export favorites/imports as .m3u
+  radiocli add-url <url> [name]
+`);
+}
+export function isDirectRun(entryPath, moduleUrl) {
+    if (!entryPath) {
+        return false;
+    }
+    try {
+        return realpathSync(resolve(entryPath)) === realpathSync(fileURLToPath(moduleUrl));
+    }
+    catch {
+        return false;
+    }
+}
+function isKnownCommand(command) {
+    return ['check', 'doctor', 'countries', 'search', 'import', 'export', 'add-url'].includes(command);
+}
+function printPlaybackBackendStatus(backends) {
+    for (const line of playbackBackendStatusLines(backends)) {
+        console.log(line);
+    }
+}

package/dist/player/backend-install.js

@@ -0,0 +1,122 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { commandExists } from './command.js';
+const playbackBackends = ['mpv', 'ffplay'];
+export function detectPlaybackBackends() {
+    return playbackBackends.filter(commandExists);
+}
+export function playbackBackendInstallHint(platform = process.platform, osRelease = readLinuxOsRelease()) {
+    return `Install mpv for playback (${mpvInstallCommand(platform, osRelease)}), then run radiocli doctor.`;
+}
+export function playbackBackendStatusLines(backends, platform = process.platform, osRelease = readLinuxOsRelease()) {
+    const backendSet = new Set(backends);
+    const lines = [
+        'npm_install=RadioCLI only; native playback comes from mpv or ffplay',
+        `install_mpv=${mpvInstallCommand(platform, osRelease)}`,
+        `optional_ffplay=${ffplayInstallCommand(platform, osRelease)}`
+    ];
+    if (backendSet.has('mpv')) {
+        return [
+            'playback=ready',
+            'playback_backend=mpv',
+            ...lines
+        ];
+    }
+    if (backendSet.has('ffplay')) {
+        return [
+            'playback=fallback-only',
+            'playback_backend=ffplay',
+            ...lines
+        ];
+    }
+    return [
+        'playback=missing',
+        'playback_backend=none',
+        ...lines
+    ];
+}
+export function mpvInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease()) {
+    if (platform === 'darwin') {
+        return 'brew install mpv';
+    }
+    if (platform === 'win32') {
+        return 'use WSL with sudo apt install mpv, or install mpv from https://mpv.io/installation/';
+    }
+    if (platform !== 'linux') {
+        return 'install mpv with your system package manager';
+    }
+    const ids = linuxReleaseIds(osRelease);
+    if (hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])) {
+        return 'sudo apt install mpv';
+    }
+    if (hasAny(ids, ['fedora', 'rhel', 'centos'])) {
+        return 'sudo dnf install mpv';
+    }
+    if (hasAny(ids, ['arch', 'manjaro'])) {
+        return 'sudo pacman -S mpv';
+    }
+    if (hasAny(ids, ['alpine'])) {
+        return 'sudo apk add mpv';
+    }
+    if (hasAny(ids, ['opensuse', 'suse'])) {
+        return 'sudo zypper install mpv';
+    }
+    return 'install mpv with your system package manager';
+}
+function ffplayInstallCommand(platform = process.platform, osRelease = readLinuxOsRelease()) {
+    if (platform === 'darwin') {
+        return 'brew install ffmpeg';
+    }
+    if (platform === 'win32') {
+        return 'use WSL with sudo apt install ffmpeg, or install FFmpeg from https://ffmpeg.org/download.html';
+    }
+    if (platform !== 'linux') {
+        return 'install FFmpeg with your system package manager';
+    }
+    const ids = linuxReleaseIds(osRelease);
+    if (hasAny(ids, ['debian', 'ubuntu', 'linuxmint', 'pop'])) {
+        return 'sudo apt install ffmpeg';
+    }
+    if (hasAny(ids, ['fedora', 'rhel', 'centos'])) {
+        return 'sudo dnf install ffmpeg';
+    }
+    if (hasAny(ids, ['arch', 'manjaro'])) {
+        return 'sudo pacman -S ffmpeg';
+    }
+    if (hasAny(ids, ['alpine'])) {
+        return 'sudo apk add ffmpeg';
+    }
+    if (hasAny(ids, ['opensuse', 'suse'])) {
+        return 'sudo zypper install ffmpeg';
+    }
+    return 'install FFmpeg with your system package manager';
+}
+function readLinuxOsRelease() {
+    if (process.platform !== 'linux' || !existsSync('/etc/os-release')) {
+        return '';
+    }
+    try {
+        return readFileSync('/etc/os-release', 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function linuxReleaseIds(osRelease) {
+    const ids = new Set();
+    for (const line of osRelease.split('\n')) {
+        const match = /^(ID|ID_LIKE)=(.*)$/.exec(line);
+        if (!match) {
+            continue;
+        }
+        for (const value of match[2].replaceAll('"', '').split(/\s+/)) {
+            const normalized = value.trim().toLowerCase();
+            if (normalized) {
+                ids.add(normalized);
+            }
+        }
+    }
+    return ids;
+}
+function hasAny(values, candidates) {
+    return candidates.some(candidate => values.has(candidate));
+}

package/dist/player/command.js

@@ -0,0 +1,8 @@
+import { spawnSync } from 'node:child_process';
+export function commandExists(command) {
+    const lookup = process.platform === 'win32' ? 'where' : 'which';
+    const result = spawnSync(lookup, [command], {
+        stdio: 'ignore'
+    });
+    return result.status === 0;
+}