nixamp 0.1.0 → 0.3.0

package/dist/rtmp-in.d.ts

@@ -0,0 +1,22 @@
+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 declare class RtmpListeners {
+    private readonly channels;
+    private readonly ffmpeg;
+    private readonly key;
+    private readonly running;
+    private stopped;
+    constructor(channels: Channels, ffmpeg: string[], key: string);
+    listen(slots: RtmpSlot[]): void;
+    private arm;
+    private done;
+    stop(): void;
+}

package/dist/rtmp-in.js

@@ -0,0 +1,79 @@
+/**
+ * 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 } from "node:child_process";
+/**
+ * Arm a listener per slot, and arm it again after each publisher leaves --
+ * otherwise a broadcaster who reconnects finds nothing listening.
+ */
+export class RtmpListeners {
+    channels;
+    ffmpeg;
+    key;
+    running = new Map();
+    stopped = false;
+    constructor(channels, ffmpeg, key) {
+        this.channels = channels;
+        this.ffmpeg = ffmpeg;
+        this.key = key;
+    }
+    listen(slots) {
+        for (const slot of slots)
+            this.arm(slot);
+    }
+    arm(slot) {
+        if (this.stopped || this.running.has(slot.port))
+            return;
+        const [command, ...prefix] = this.ffmpeg;
+        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 = null;
+        child.stdout?.on("data", (chunk) => {
+            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));
+    }
+    done(slot, child, channel) {
+        if (this.running.get(slot.port) !== child)
+            return;
+        this.running.delete(slot.port);
+        channel?.close();
+        if (!this.stopped)
+            this.arm(slot);
+    }
+    stop() {
+        this.stopped = true;
+        for (const child of this.running.values())
+            child.kill("SIGKILL");
+        this.running.clear();
+    }
+}

package/dist/server.d.ts

@@ -1,4 +1,11 @@
 import { type IncomingMessage, type Server, type ServerResponse } from "node:http";
+import { Connections } from "./connections.ts";
+import { Broadcaster, type Destination, type EncoderSettings } from "./broadcast.ts";
+import { Ingest } from "./ingest.ts";
+import { Channels } from "./channels.ts";
+import { Accounts } from "./accounts.ts";
+import { Owner } from "./owner.ts";
+import { Directory } from "./directory.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
 export declare const SERVE_BAND_COUNT = 24;
@@ -11,6 +18,57 @@ export interface ServeOptions {
     web: string | null;
     /** Stream the library's bytes to remotes. Off keeps the audio on this box. */
     media: boolean;
+    /**
+     * Require the key from the share link. Off serves to anyone who can reach the
+     * port, which is what the public deployment wants and no private one does.
+     */
+    key: boolean;
+    /**
+     * Ask the local firewall to let the port through, and put it back on the way
+     * out. Off by default because it changes the machine, not just this process.
+     */
+    openPort: boolean;
+    /**
+     * Print one JSON line once listening. `nixamp daemon start` reads it rather
+     * than sleeping and hoping, so a daemon that failed to bind is reported as
+     * failed instead of started.
+     */
+    announce: boolean;
+    /** Host the public directory. Only the deployment behind nixamp.com does. */
+    directory: boolean;
+    /**
+     * List this stream at nixamp.com/directory. "ask" prompts, and is the
+     * default: publishing an address without being asked is not something a
+     * player gets to decide for you.
+     */
+    publish: "ask" | "yes" | "no";
+    /** What to call it in the list. Defaults to this machine's hostname. */
+    name: string;
+    /**
+     * Charge for listening once the stream is busy. Off unless asked for, and
+     * useless without somewhere to pay: see NIXAMP_PAY_TO.
+     */
+    x402: boolean;
+    /** The account id that may administer this server, if not the signed-in one. */
+    owner: string;
+    /** Accept a live stream from a phone or a desktop, over HTTP. */
+    ingest: boolean;
+    /**
+     * Also listen for RTMP publishers on this port, which is what OBS, Larix and
+     * anything else native speaks. 0 means do not.
+     */
+    rtmpIn: number;
+    /**
+     * How many RTMP publishers may be live at once. ffmpeg's listener serves one
+     * connection per process, so this is a port and a process each: 1935, 1936,
+     * and so on. HTTP publishers are not limited by this.
+     */
+    rtmpStreams: number;
+    /**
+     * RTMP destinations, as `name=rtmp://host/app/key` or `youtube=key` for one
+     * of the presets. Repeatable.
+     */
+    rtmp: string[];
 }
 /**
  * Flags are parsed by hand: three of them do not justify a dependency, and the
@@ -40,6 +98,12 @@ export interface Engine {
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     /** Absolute path of a track, or undefined when the index is not one. */
     trackPath(index: number): string | undefined;
+    /**
+     * Play something else instead. Re-streaming is the whole reason the admin
+     * view exists: point a running server at a URL without restarting it and
+     * dropping every listener.
+     */
+    replace(tracks: Track[], root: string): void;
     stop(): void;
 }
 export declare function toRemoteTracks(tracks: Track[]): RemoteTrack[];
@@ -49,8 +113,8 @@ export declare function toRemoteTracks(tracks: Track[]): RemoteTrack[];
  * its way past so a remote can draw the same spectrum the TUI would.
  */
 export declare class PlayerEngine implements Engine {
-    private readonly tracks;
-    private readonly root;
+    private tracks;
+    private root;
     /** Frames a second pushed to remotes. */
     private readonly fps;
     private readonly listeners;
@@ -78,6 +142,7 @@ export declare class PlayerEngine implements Engine {
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     private push;
     stop(): void;
+    replace(tracks: Track[], root: string): void;
 }
 /** An engine with no library behind it, for the hosted PWA. */
 export declare class EmptyEngine implements Engine {
@@ -87,12 +152,54 @@ export declare class EmptyEngine implements Engine {
     command(): void;
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     trackPath(): undefined;
+    replace(): void;
     stop(): void;
 }
 export interface HandlerOptions {
     web: string | null;
     media: boolean;
     version: string;
+    /** The key from the share link, or null to serve to anyone who can connect. */
+    key?: string | null;
+    /**
+     * A second key that may listen but not drive. The public directory hands
+     * this one out: a link that lets a stranger pause your music is not a link
+     * you can publish.
+     */
+    listenKey?: string | null;
+    /** How to run ffmpeg, for the sources a browser cannot play by itself. */
+    ffmpeg?: string[];
+    /** Who is listening, for the admin view. */
+    connections?: Connections;
+    /**
+     * How to turn a source into tracks, for re-streaming. Injected rather than
+     * imported so the handler stays a plain function of a request.
+     */
+    load: (source: string) => Promise<Track[]>;
+    /**
+     * The public directory, on the instance that hosts one. Only nixamp.com
+     * passes this; a nixamp on your laptop is a publisher, not a registry.
+     */
+    directory?: Directory;
+    /** Answers a request itself when listening has to be paid for. */
+    paywall?: (request: IncomingMessage, response: ServerResponse, path: string) => Promise<boolean>;
+    /** Live audio coming in from a phone or a desktop. */
+    ingest?: Ingest;
+    /** Several live streams at once, each with its own audience. */
+    channels?: Channels;
+    /** Live audio going out to RTMP. */
+    broadcaster?: Broadcaster;
+    /** Where a broadcast should send, and what it should look like. */
+    broadcast?: () => {
+        destinations: Destination[];
+        settings: EncoderSettings;
+    };
+    /** Accounts, on the instance that keeps them. Only nixamp.com passes this. */
+    accounts?: Accounts;
+    /** True when this instance is reached over https, for the cookie's Secure. */
+    secureCookies?: boolean;
+    /** Who may administer this server. */
+    owner?: Owner;
 }
 /**
  * The whole HTTP surface, as a plain function of a request — so a test can
@@ -100,6 +207,12 @@ export interface HandlerOptions {
  */
 export declare function createHandler(engine: Engine, options: HandlerOptions): (request: IncomingMessage, response: ServerResponse) => Promise<void>;
 export declare function createServer(engine: Engine, options: HandlerOptions): Server;
-/** Where a remote on another device should point its browser. */
-export declare function addressesFor(host: string, port: number): string[];
 export declare function serve(argv: string[], version?: string): Promise<void>;
+/**
+ * `--rtmp youtube=<key>` or `--rtmp name=rtmp://host/app/key`.
+ *
+ * A key is a password, so it is taken from the command line or the environment
+ * and never from a request: a client that could name its own destination could
+ * point your broadcast at itself.
+ */
+export declare function parseDestinations(specs: string[]): Destination[];