@ciphore/radiocli 0.2.4 → 0.2.6

package/dist/storage/repository.js

@@ -0,0 +1,247 @@
+import { Worker } from 'node:worker_threads';
+import { stationKey } from './store.js';
+const methods = ['snapshot', 'savePreset', 'removePreset', 'exportBackup', 'importBackup', 'updateSettings', 'updateCheckState',
+    'addAlarm', 'updateAlarm', 'removeAlarm', 'toggleAlarm', 'recordAlarmOutcome', 'snoozeAlarm', 'clearAlarmSnooze',
+    'addRecent', 'recordTrack', 'addSearch', 'startListeningSession', 'checkpointActiveListeningSession',
+    'finishActiveListeningSession', 'toggleFavorite', 'addImported'];
+/** One ordered transactional writer, off the UI/audio event loop. Sync stores remain
+ * usable for short-lived commands and injected adapters; success follows persistence. */
+export class LibraryRepository {
+    store;
+    filePath;
+    state;
+    listeners = new Set();
+    errors = new Set();
+    pending = new Map();
+    worker;
+    nextId = 1;
+    inlineQueue = Promise.resolve();
+    closed = false;
+    failure;
+    closing;
+    workerReady = false;
+    fallbackRefresh;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.filePath = store.filePath;
+        this.state = store.snapshot();
+        if (options.worker === false) {
+            this.startFallbackRefresh();
+            return;
+        }
+        const source = import.meta.url.endsWith('.ts');
+        const storeUrl = new URL(source ? './store.ts' : './store.js', import.meta.url).href;
+        try {
+            this.worker = new Worker(repositoryWorker, { eval: true, workerData: { storeUrl, source, filePath: this.filePath, methods }, execArgv: [] });
+        }
+        catch {
+            this.startFallbackRefresh();
+            return; /* Some restricted hosts disable threads; transactional storage still works. */
+        }
+        this.worker.on('message', (reply) => this.receive(reply));
+        this.worker.on('error', error => this.fail(error));
+        this.worker.on('exit', code => { if (!this.closed)
+            this.fail(new Error(`Library worker exited (${code}).`)); });
+        this.worker.unref();
+    }
+    snapshot() { return structuredClone(this.state); }
+    getSnapshot() { return this.state; }
+    settings() { return structuredClone(this.state.settings); }
+    listAlarms() { return structuredClone(this.state.alarms); }
+    getAlarm(id) { return structuredClone(this.state.alarms.find(alarm => alarm.id === id)); }
+    isFavorite(station) { return Boolean(station && this.state.favorites.some(item => stationKey(item) === stationKey(station))); }
+    subscribe(listener) { this.listeners.add(listener); return () => this.listeners.delete(listener); }
+    onError(listener) { this.errors.add(listener); return () => this.errors.delete(listener); }
+    readFresh() { return this.call('snapshot'); }
+    savePreset(name, station) { return this.call('savePreset', name, station); }
+    removePreset(name) { return this.call('removePreset', name); }
+    exportBackup(path) { return this.call('exportBackup', path); }
+    importBackup(path) { return this.call('importBackup', path); }
+    updateSettings(settings) { return this.call('updateSettings', settings); }
+    updateCheckState(state) { return this.call('updateCheckState', state); }
+    addAlarm(input) { return this.call('addAlarm', input); }
+    updateAlarm(id, updates) { return this.call('updateAlarm', id, updates); }
+    removeAlarm(id) { return this.call('removeAlarm', id); }
+    toggleAlarm(id, enabled) { return this.call('toggleAlarm', id, enabled); }
+    recordAlarmOutcome(id, outcome, options) { return this.call('recordAlarmOutcome', id, outcome, options); }
+    snoozeAlarm(id, until) { return this.call('snoozeAlarm', id, until); }
+    clearAlarmSnooze(id) { return this.call('clearAlarmSnooze', id); }
+    addRecent(station) { return this.call('addRecent', station); }
+    recordTrack(station, title) { return this.call('recordTrack', station, title); }
+    addSearch(query) { return this.call('addSearch', query); }
+    startListeningSession(station, at = new Date()) { return this.call('startListeningSession', station, at); }
+    checkpointActiveListeningSession(at = new Date()) { return this.call('checkpointActiveListeningSession', at); }
+    finishActiveListeningSession(at = new Date()) { return this.call('finishActiveListeningSession', at); }
+    toggleFavorite(station) { return this.call('toggleFavorite', station); }
+    addImported(stations) { return this.call('addImported', stations); }
+    async flush() {
+        // A barrier command follows every previously submitted semantic mutation.
+        await this.readFresh();
+    }
+    close() {
+        return this.closing ??= (async () => {
+            try {
+                await this.flush();
+            }
+            finally {
+                this.closed = true;
+                clearInterval(this.fallbackRefresh);
+                await this.worker?.terminate();
+                for (const pending of this.pending.values())
+                    pending.reject(new Error('RadioCLI library repository is closed.'));
+                this.pending.clear();
+                this.listeners.clear();
+                this.errors.clear();
+            }
+        })();
+    }
+    call(method, ...args) {
+        if (this.closed || this.closing)
+            return Promise.reject(new Error('RadioCLI library repository is closed.'));
+        return this.enqueue(method, args);
+    }
+    enqueue(method, args) {
+        if (this.failure)
+            return Promise.reject(this.failure);
+        if (!this.worker) {
+            const result = this.inlineQueue.catch(() => undefined).then(() => {
+                const operation = this.store[method];
+                const value = operation.apply(this.store, args);
+                this.publish(this.store.cachedSnapshot());
+                return value;
+            });
+            this.inlineQueue = result;
+            return result;
+        }
+        const id = this.nextId++;
+        this.worker.ref();
+        return new Promise((resolve, reject) => {
+            const request = { id, method, args };
+            this.pending.set(id, { request, resolve: value => resolve(value), reject });
+            try {
+                if (this.workerReady)
+                    this.worker.postMessage(request);
+            }
+            catch (error) {
+                this.pending.delete(id);
+                reject(error);
+                if (!this.pending.size)
+                    this.worker.unref();
+            }
+        });
+    }
+    receive(reply) {
+        if (reply.state)
+            this.publish(reply.state);
+        if (reply.ready) {
+            this.workerReady = true;
+            for (const { request } of this.pending.values())
+                this.worker.postMessage(request);
+            return;
+        }
+        if (reply.id === undefined) {
+            if (reply.error)
+                this.report(deserializeError(reply.error));
+            return;
+        }
+        const pending = this.pending.get(reply.id);
+        this.pending.delete(reply.id);
+        if (reply.error)
+            pending?.reject(deserializeError(reply.error));
+        else
+            pending?.resolve(reply.result);
+        if (!this.pending.size)
+            this.worker?.unref();
+    }
+    publish(state) {
+        this.state = state;
+        for (const listener of this.listeners) {
+            try {
+                listener(state);
+            }
+            catch { /* Consumers cannot invalidate a durable commit. */ }
+        }
+    }
+    report(error) { for (const listener of this.errors) {
+        try {
+            listener(error);
+        }
+        catch { /* Isolate observers. */ }
+    } }
+    fail(error) {
+        if (!this.workerReady && this.worker) {
+            const worker = this.worker;
+            this.worker = undefined;
+            void worker.terminate();
+            this.startFallbackRefresh();
+            // No operation is sent before the ready handshake, so this fallback cannot
+            // replay a possibly committed toggle or alarm mutation.
+            const waiting = [...this.pending.values()];
+            this.pending.clear();
+            for (const pending of waiting)
+                void this.enqueue(pending.request.method, pending.request.args).then(pending.resolve, pending.reject);
+            this.report(new Error(`Library worker unavailable; using transactional storage: ${error.message}`));
+            return;
+        }
+        if (!this.workerReady && !this.worker)
+            return;
+        this.failure = error;
+        for (const request of this.pending.values())
+            request.reject(error);
+        this.pending.clear();
+        this.worker?.unref();
+        this.report(error);
+    }
+    startFallbackRefresh() {
+        this.fallbackRefresh ??= setInterval(() => {
+            if (this.closed || this.closing)
+                return;
+            const refresh = this.inlineQueue.catch(() => undefined).then(() => {
+                if (this.store.refresh())
+                    this.publish(this.store.cachedSnapshot());
+            }).catch(error => this.report(error instanceof Error ? error : new Error(String(error))));
+            this.inlineQueue = refresh;
+        }, 1000);
+        this.fallbackRefresh.unref();
+    }
+}
+function deserializeError(value) {
+    return Object.assign(new Error(value.message), { name: value.name, ...(value.code ? { code: value.code } : {}) });
+}
+// Only enumerated semantic operations cross the worker boundary. No user data
+// becomes executable code. Source mode uses the existing development runner;
+// the packed build loads ordinary ESM and has no development dependency.
+const repositoryWorker = `
+const {parentPort, workerData} = require('node:worker_threads');
+const {watch} = require('node:fs');
+const {dirname} = require('node:path');
+(async () => {
+  const module = workerData.source
+    ? await (await import('tsx/esm/api')).tsImport(workerData.storeUrl, {parentURL: workerData.storeUrl})
+    : await import(workerData.storeUrl);
+  const store = new module.JsonLibraryStore(workerData.filePath);
+  const allowed = new Set(workerData.methods);
+  const errorValue = error => ({message: error.message || 'Library operation failed.', name: error.name || 'Error', code: error.code});
+  let queue = Promise.resolve();
+  let watcher;
+  const refresh = () => {
+    try { if (store.refresh()) parentPort.postMessage({state: store.snapshot()}); }
+    catch (error) { parentPort.postMessage({error: errorValue(error)}); }
+  };
+  try { watcher = watch(dirname(workerData.filePath), {persistent: false}, () => { queue = queue.catch(() => {}).then(refresh); }); }
+  catch { /* Missing folders and platforms without watchers use the revision fallback. */ }
+  const timer = setInterval(() => { queue = queue.catch(() => {}).then(refresh); }, 1000);
+  timer.unref();
+  parentPort.on('message', request => {
+    queue = queue.catch(() => {}).then(async () => {
+      try {
+        if (!allowed.has(request.method)) throw new Error('Unknown library operation.');
+        const result = await store[request.method](...request.args);
+        const state = result && result.settings && result.activity ? result : store.cachedSnapshot();
+        parentPort.postMessage({id: request.id, result, state});
+      } catch (error) { parentPort.postMessage({id: request.id, error: errorValue(error)}); }
+    });
+  });
+  parentPort.postMessage({ready: true, state: store.snapshot()});
+})().catch(error => { throw error; });
+`;

package/dist/storage/station-identity.js

@@ -0,0 +1,21 @@
+import { createHash } from 'node:crypto';
+/** Paths and signed query parameters are significant: hash the exact target. */
+export function customStationId(target) {
+    return `custom-v2-${createHash('sha256').update(target).digest('hex')}`;
+}
+function legacyCustomStationId(target) {
+    let hash = 0;
+    for (let index = 0; index < target.length; index += 1)
+        hash = (hash * 31 + target.charCodeAt(index)) >>> 0;
+    return `custom-${hash.toString(16)}`;
+}
+/** Only migrate IDs this application generated; preserve user-assigned IDs. */
+export function migrateStationIdentity(station) {
+    if (station.provider !== 'playlist' || !station.streamUrl || station.id !== legacyCustomStationId(station.streamUrl))
+        return station;
+    return { ...station, id: customStationId(station.streamUrl), legacyIds: [...new Set([...(station.legacyIds ?? []), station.id])] };
+}
+export function matchesStationId(station, id) {
+    const normalized = id.replace(new RegExp(`^${station.provider}:`), '');
+    return station.id === normalized || Boolean(station.legacyIds?.includes(normalized));
+}

package/dist/storage/station-schema.js

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export const stationSchema = z
+    .object({
+    id: z.string(),
+    legacyIds: z.array(z.string()).optional(),
+    provider: z.enum(['radio-browser', 'radio-garden', 'playlist']),
+    name: z.string(),
+    country: z.string().optional(),
+    countryCode: z.string().optional(),
+    state: z.string().optional(),
+    city: z.string().optional(),
+    language: z.string().optional(),
+    languageCodes: z.array(z.string()).optional(),
+    tags: z.array(z.string()),
+    codec: z.string().optional(),
+    bitrate: z.number().optional(),
+    homepage: z.string().optional(),
+    favicon: z.string().optional(),
+    streamUrl: z.string().optional(),
+    clickCount: z.number().optional(),
+    votes: z.number().optional(),
+    latitude: z.number().optional(),
+    longitude: z.number().optional(),
+    distanceKm: z.number().optional(),
+    hls: z.boolean().optional(),
+    lastCheckedOk: z.boolean().optional()
+});