feat(streamer): now-playing watcher with cover resolver

streamer/src/nowplaying.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from "node:events";
+import { existsSync, readFileSync, watch, FSWatcher } from "node:fs";
+import { join } from "node:path";
+
+export interface NowPlayingTrack {
+  title: string;
+  artist: string;
+  album: string;
+  duration: string;
+  cover_path: string;
+}
+
+export interface NowPlayingState {
+  station: string;
+  title: string;
+  artist: string;
+  album: string;
+  filename: string;
+  duration: string;
+  started_at: string;
+  cover_path: string;
+  cover_url: string;
+  up_next: (NowPlayingTrack & { cover_url: string })[];
+}
+
+export interface NowPlayingOpts {
+  station: string;
+  nowPlayingDir: string;
+  libraryDir: string;
+}
+
+export class NowPlayingWatcher extends EventEmitter {
+  private state: NowPlayingState | null = null;
+  private watcher: FSWatcher | null = null;
+  private debounce: NodeJS.Timeout | null = null;
+  private path: string;
+
+  constructor(private opts: NowPlayingOpts) {
+    super();
+    this.path = join(opts.nowPlayingDir, `${opts.station}.json`);
+  }
+
+  async start(): Promise<void> {
+    this.read();
+    this.watcher = watch(this.opts.nowPlayingDir, (_event, filename) => {
+      if (filename !== `${this.opts.station}.json`) return;
+      if (this.debounce) clearTimeout(this.debounce);
+      this.debounce = setTimeout(() => this.read(), 50);
+    });
+  }
+
+  stop(): void {
+    this.watcher?.close();
+    this.watcher = null;
+    if (this.debounce) clearTimeout(this.debounce);
+  }
+
+  current(): NowPlayingState | null {
+    return this.state;
+  }
+
+  private read(): void {
+    if (!existsSync(this.path)) return;
+    try {
+      const raw = readFileSync(this.path, "utf8");
+      const parsed = JSON.parse(raw);
+      const cover_path = this.resolveCover(parsed.cover_path, parsed.filename);
+      const up_next = (parsed.up_next ?? []).map((t: NowPlayingTrack) => ({
+        ...t,
+        cover_url: this.coverUrl(this.resolveCover(t.cover_path, "")),
+      }));
+      this.state = {
+        ...parsed,
+        cover_path,
+        cover_url: this.coverUrl(cover_path),
+        up_next,
+      };
+      this.emit("change", this.state);
+    } catch (err) {
+      this.emit("warn", err);
+    }
+  }
+
+  private resolveCover(suggested: string, _filename: string): string {
+    if (suggested && existsSync(this.toAbsolute(suggested))) return suggested;
+    const stationCover = `/library/${this.opts.station}/cover.jpg`;
+    if (existsSync(this.toAbsolute(stationCover))) return stationCover;
+    return "";
+  }
+
+  private toAbsolute(libraryPath: string): string {
+    if (!libraryPath.startsWith("/library/")) return libraryPath;
+    return join(this.opts.libraryDir, libraryPath.slice("/library/".length));
+  }
+
+  private coverUrl(libraryPath: string): string {
+    if (!libraryPath) return "";
+    return `/cover?path=${encodeURIComponent(libraryPath)}`;
+  }
+}