nixamp 0.2.0 → 0.3.0

package/src/publish.ts

@@ -0,0 +1,101 @@
+/**
+ * Publishing to the directory, and asking first.
+ *
+ * Listing a stream tells the world an address it can reach you on, so it is
+ * never done silently. The prompt defaults to yes; a terminal that cannot ask
+ * defaults to no, because "there was nobody to ask" is not consent.
+ */
+import { createInterface } from "node:readline/promises";
+import { DEFAULT_DIRECTORY, HEARTBEAT_MS, type Listing } from "./directory.ts";
+
+export interface PublishTarget {
+  directory: string;
+  name: string;
+  /** The listen link: what a stranger opens. Never the control key. */
+  url: string;
+  tracks: number;
+  nowPlaying: () => string;
+  /**
+   * Called with whatever configuration the directory sent back. This is how
+   * nixamp.com turns x402 on and off for a server without it restarting.
+   */
+  onConfig?: (config: unknown) => void;
+}
+
+/**
+ * Ask, with yes as the default. Returns false without asking when there is no
+ * terminal on the other end, which is the case for the daemon and for CI.
+ */
+export async function confirm(question: string, tty = process.stdin.isTTY === true): Promise<boolean> {
+  if (!tty) return false;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`${question} [Y/n] `)).trim().toLowerCase();
+    return answer === "" || answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+/**
+ * Announce, then keep announcing. The directory forgets an entry that stops
+ * renewing, so stopping the heartbeat is how a stream leaves the list even if
+ * the process dies without saying goodbye.
+ */
+export class Publisher {
+  private id: string | null = null;
+  private timer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly target: PublishTarget,
+    private readonly fetcher: typeof fetch = fetch,
+  ) {}
+
+  async start(): Promise<Listing | null> {
+    const first = await this.announce();
+    this.timer = setInterval(() => void this.announce(), HEARTBEAT_MS);
+    this.timer.unref?.();
+    return first;
+  }
+
+  async announce(): Promise<Listing | null> {
+    try {
+      const response = await this.fetcher(`${this.target.directory}/api/directory`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          ...(this.id ? { id: this.id } : {}),
+          name: this.target.name,
+          url: this.target.url,
+          tracks: this.target.tracks,
+          nowPlaying: this.target.nowPlaying(),
+        }),
+      });
+      if (!response.ok) return null;
+      const listing = (await response.json()) as Listing & { config?: unknown };
+      this.id = listing.id;
+      if (listing.config !== undefined) this.target.onConfig?.(listing.config);
+      return listing;
+    } catch {
+      // The directory being down is not a reason for a player to stop playing.
+      return null;
+    }
+  }
+
+  /** Leave the list now rather than waiting to be forgotten. */
+  async stop(): Promise<void> {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+    if (this.id === null) return;
+    try {
+      await this.fetcher(`${this.target.directory}/api/directory?id=${encodeURIComponent(this.id)}`, {
+        method: "DELETE",
+      });
+    } catch {
+      // It expires on its own within the TTL, which is the point of the TTL.
+    }
+    this.id = null;
+  }
+}
+
+export { DEFAULT_DIRECTORY };

package/src/rtmp-in.ts

@@ -0,0 +1,90 @@
+/**
+ * RTMP publishers, several at once.
+ *
+ * ffmpeg's RTMP listener serves one connection and exits, so N simultaneous
+ * publishers means N listeners on N ports. That is the honest cost of using
+ * ffmpeg as the RTMP server rather than implementing the protocol, and it buys
+ * a broadcaster that every phone and desktop app already speaks.
+ *
+ * Each listener decodes to MP3 itself, so its channel fans those bytes out
+ * without decoding them a second time.
+ */
+import { spawn, type ChildProcess } from "node:child_process";
+import type { Channels } from "./channels.ts";
+
+export interface RtmpSlot {
+  port: number;
+  /** The channel a publisher on this port lands on. */
+  id: string;
+}
+
+/**
+ * Arm a listener per slot, and arm it again after each publisher leaves --
+ * otherwise a broadcaster who reconnects finds nothing listening.
+ */
+export class RtmpListeners {
+  private readonly running = new Map<number, ChildProcess>();
+  private stopped = false;
+
+  constructor(
+    private readonly channels: Channels,
+    private readonly ffmpeg: string[],
+    private readonly key: string,
+  ) {}
+
+  listen(slots: RtmpSlot[]): void {
+    for (const slot of slots) this.arm(slot);
+  }
+
+  private arm(slot: RtmpSlot): void {
+    if (this.stopped || this.running.has(slot.port)) return;
+
+    const [command, ...prefix] = this.ffmpeg as [string, ...string[]];
+    const child = spawn(
+      command,
+      [
+        ...prefix,
+        "-hide_banner",
+        "-loglevel", "error",
+        "-rtmp_listen", "1",
+        // Wait indefinitely: a stream that starts tomorrow is still the stream.
+        "-timeout", "-1",
+        "-f", "flv",
+        "-i", `rtmp://0.0.0.0:${slot.port}/live/${this.key}`,
+        "-vn",
+        "-c:a", "libmp3lame",
+        "-b:a", "192k",
+        "-y",
+        "-f", "mp3",
+        "pipe:1",
+      ],
+      { stdio: ["ignore", "pipe", "pipe"] },
+    );
+    this.running.set(slot.port, child);
+
+    // The first bytes are the only honest signal that a publisher turned up:
+    // ffmpeg does not announce a connect, and a healthy stream says nothing at
+    // -loglevel error.
+    let channel: ReturnType<Channels["attach"]> = null;
+    child.stdout?.on("data", (chunk: Buffer) => {
+      channel ??= this.channels.attach(slot.id, "an RTMP publisher", "flv", "rtmp");
+      channel?.feed(chunk);
+    });
+    child.stdout?.on("error", () => child.kill("SIGKILL"));
+    child.on("error", () => this.done(slot, child, channel));
+    child.on("close", () => this.done(slot, child, channel));
+  }
+
+  private done(slot: RtmpSlot, child: ChildProcess, channel: { close(): void } | null): void {
+    if (this.running.get(slot.port) !== child) return;
+    this.running.delete(slot.port);
+    channel?.close();
+    if (!this.stopped) this.arm(slot);
+  }
+
+  stop(): void {
+    this.stopped = true;
+    for (const child of this.running.values()) child.kill("SIGKILL");
+    this.running.clear();
+  }
+}