nixamp 0.7.5 → 0.7.7

package/dist/admin.js

@@ -21,7 +21,15 @@ export function resolveTarget(argv) {
     }
     const state = readState();
     if (state === null) {
-        throw new Error("nixamp: no daemon is running. Start one with `nixamp daemon start`, or pass --url.");
+        // Named, with an example. "or pass --url" is only an instruction if you
+        // already know what belongs after it, and the whole point of this message
+        // is that you are looking at a machine you have no handle on.
+        throw new Error("nixamp: no daemon is running on this machine.\n" +
+            "  Start one:        nixamp daemon start ~/Music\n" +
+            "  Or administer another machine, with its share link:\n" +
+            "                    nixamp admin --url https://server1.you.nixamp.com:4321 --key KEY\n" +
+            "  The URL and key are the two halves of the link that server printed:\n" +
+            "  https://host:4321/s/KEY");
     }
     const url_ = daemonUrl(state);
     // Talking to our own daemon, whose certificate names somewhere else. Nothing

package/dist/audio.d.ts

@@ -78,6 +78,17 @@ export interface Codecs {
     video: string;
     /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
     audio: string;
+    /**
+     * What is wrapped around them: "mpegts", "matroska,webm", "mov,mp4,...".
+     *
+     * It matters for one reason. A transport stream -- which is what every IPTV
+     * channel is -- frames its AAC as ADTS, and copying that into MP4 needs a
+     * bitstream filter or ffmpeg refuses the whole muxing and writes nothing.
+     * They also tend to carry several audio tracks, so the one ffmpeg picks can
+     * be AC-3 on the same URL that offered AAC a minute earlier, and AC-3 in MP4
+     * is a track no browser will play.
+     */
+    container: string;
 }
 /**
  * Ask ffprobe what the streams are, without holding the event loop.

package/dist/audio.js

@@ -284,7 +284,7 @@ function readTags(stdout, fallback) {
  */
 export async function codecsOf(tools, path) {
     const [cmd, ...rest] = tools.ffprobe;
-    const empty = { video: "", audio: "" };
+    const empty = { video: "", audio: "", container: "" };
     if (!cmd)
         return empty;
     return new Promise((done) => {
@@ -292,7 +292,7 @@ export async function codecsOf(tools, path) {
             ...rest,
             "-v", "quiet",
             "-print_format", "json",
-            "-show_entries", "stream=codec_type,codec_name",
+            "-show_entries", "format=format_name:stream=codec_type,codec_name",
             path,
         ], { stdio: ["ignore", "pipe", "ignore"] });
         let out = "";
@@ -307,6 +307,7 @@ export async function codecsOf(tools, path) {
                 return done({
                     video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
                     audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
+                    container: parsed.format?.format_name ?? "",
                 });
             }
             catch {
@@ -331,7 +332,13 @@ export function videoArgs(codecs, capKbps = 0) {
         return cappedArgs(capKbps);
     // What a browser can play inside MP4 without help.
     const keepVideo = codecs.video === "h264";
-    const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+    // A transport stream's audio is never copied. Its AAC is ADTS-framed, which
+    // MP4 refuses without a bitstream filter -- ffmpeg writes nothing at all and
+    // says "Malformed AAC bitstream detected" -- and the track ffmpeg picks off
+    // a channel with several of them can be AC-3, which that filter rejects and
+    // no browser plays. Re-encoding audio is cheap; this failing is total.
+    const transportStream = codecs.container.includes("mpegts");
+    const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
     return [
         "-c:v", keepVideo ? "copy" : "libx264",
         ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),

package/dist/daemon.d.ts

@@ -27,6 +27,15 @@ export interface DaemonState {
      * interface, so it names the router and not this port.
      */
     guessedPublic?: boolean;
+    /**
+     * What it was started with, so it can be started that way again.
+     *
+     * A daemon serving TLS on a public name is six flags, and restarting it
+     * meant finding them again -- from shell history, or from `ps`, or not at
+     * all. Absent on a state file written by an older nixamp, which is why
+     * `restart` says so rather than starting something different.
+     */
+    argv?: string[];
 }
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
 export declare function stateDir(): string;
@@ -75,5 +84,16 @@ export declare function daemonLines(state: DaemonState, uptimeMs?: number): stri
  * log file is the thing this is meant to avoid.
  */
 export declare function start(argv: string[], entry: string): Promise<DaemonState>;
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export declare function restart(argv: string[], entry: string, 
+/** Injected so a test can see which arguments would be replayed. */
+starter?: typeof start): Promise<DaemonState>;
 /** Stop it, and wait for it to actually be gone. */
 export declare function stop(timeoutMs?: number): Promise<boolean>;

package/dist/daemon.js

@@ -178,10 +178,30 @@ export async function start(argv, entry) {
         }
         throw new Error(`nixamp: the daemon did not start. See ${log}`);
     }
-    const state = { ...announced, pid: child.pid, startedAt: Date.now(), log };
+    const state = { ...announced, pid: child.pid, startedAt: Date.now(), log, argv };
     writeState(state);
     return state;
 }
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export async function restart(argv, entry, 
+/** Injected so a test can see which arguments would be replayed. */
+starter = start) {
+    const { state } = status();
+    const before = state?.argv;
+    if (argv.length === 0 && before === undefined && state !== null) {
+        throw new Error("nixamp: this daemon was started by an older nixamp, which did not record its flags. " +
+            "Stop it and start it again with the flags you want.");
+    }
+    await stop();
+    return starter(argv.length > 0 ? argv : (before ?? []), entry);
+}
 /** Poll the log for the announce line. */
 async function waitForAnnounce(log, timeoutMs) {
     const deadline = Date.now() + timeoutMs;

package/dist/invite.d.ts

@@ -2,9 +2,11 @@
  * Asking somebody to watch, when that somebody is not technical.
  *
  * A share link is a URL with a key in it, which is fine for the person who
- * runs the server and useless as a thing to text your mother. An invite is the
- * three ways in, written as a sentence: a link that opens a player, a phone
- * number, and the code to key once it answers.
+ * runs the server and useless as a thing to text your mother. An invite is two
+ * things written as a sentence: a link that opens a player, and a phone number
+ * with a code, which is the line where everyone watching talks to each other.
+ * The phone is not another way to hear the stream -- it is the 800 number
+ * beside a podcast. The show is on the screen; the call is the company.
  *
  * The sender is signed in, because sending is an action with a cost: a text
  * message is money and somebody's phone. The recipient signs in too, but only
@@ -21,7 +23,7 @@ export interface Invite {
     link: string;
     /** The phone number, when this stream is one the line knows about. */
     phone: string;
-    /** The six digits that reach this stream, when it has been published. */
+    /** The six digits that reach this stream's room, once it has been published. */
     code: string;
 }
 /** Looks like a phone number rather than an address. */

package/dist/invite.js

@@ -2,9 +2,11 @@
  * Asking somebody to watch, when that somebody is not technical.
  *
  * A share link is a URL with a key in it, which is fine for the person who
- * runs the server and useless as a thing to text your mother. An invite is the
- * three ways in, written as a sentence: a link that opens a player, a phone
- * number, and the code to key once it answers.
+ * runs the server and useless as a thing to text your mother. An invite is two
+ * things written as a sentence: a link that opens a player, and a phone number
+ * with a code, which is the line where everyone watching talks to each other.
+ * The phone is not another way to hear the stream -- it is the 800 number
+ * beside a podcast. The show is on the screen; the call is the company.
  *
  * The sender is signed in, because sending is an action with a cost: a text
  * message is money and somebody's phone. The recipient signs in too, but only
@@ -32,7 +34,10 @@ export function isEmail(value) {
 export function inviteText(invite) {
     const lines = [`${invite.name} is streaming.`, "", `Watch: ${invite.link}`];
     if (invite.phone && invite.code) {
-        lines.push("", `Or call ${invite.phone} and key ${invite.code} to listen.`);
+        // "to talk about it", not "to listen": the line is a room full of the
+        // other people watching, and telling somebody they will hear the stream
+        // down the phone is telling them something that is not true.
+        lines.push("", `To talk about it: call ${invite.phone} and key ${invite.code}.`);
     }
     return lines.join("\n");
 }

package/dist/main.js

@@ -45,7 +45,7 @@ const HELP = `nixamp — it really whips the terminal's ass.
 
   nixamp [source]                play it in the terminal
   nixamp serve [source] [options]  play here, and hand out a browser remote
-  nixamp daemon start|stop|status  serve in the background, and let go of it
+  nixamp daemon start|restart|stop|status  serve in the background, and let go of it
   nixamp attach                  put the player back in front of the daemon
   nixamp admin [--url U] [--key K] who is connected, and re-stream to them
   nixamp login [--with github]  sign in to nixamp.com, in a browser or here
@@ -162,9 +162,13 @@ Signing out does not touch it: that is what it is for.
     daemon: `nixamp daemon — a nixamp that outlives the terminal that started it.
 
   nixamp daemon start [source] [serve options]   start it, detached
+  nixamp daemon restart [source] [serve options] stop it and start it again
   nixamp daemon status                           where it is, and how long
   nixamp daemon stop                             stop it
 
+Restart with no arguments replays the ones it was started with, certificate
+and public URL included, so picking up a new version costs one command.
+
 It is \`nixamp serve\` with nobody holding its terminal, so it keeps playing and
 keeps serving its browser remote. One per user.
 
@@ -228,6 +232,18 @@ async function runDaemon(argv) {
         console.log(stopped ? "nixamp daemon stopped" : "nixamp: no daemon was running");
         return 0;
     }
+    if (action === "restart") {
+        try {
+            const state = await d.restart(rest, entry);
+            for (const line of d.daemonLines(state))
+                console.log(line);
+            return 0;
+        }
+        catch (error) {
+            console.error(error.message);
+            return 1;
+        }
+    }
     if (action === "status") {
         const { running, state } = d.status();
         if (!state) {
@@ -253,7 +269,7 @@ async function runDaemon(argv) {
         const { attach } = await import("./attach.js");
         return attach(rest);
     }
-    console.error(`nixamp daemon: unknown action ${action}. Try start, stop, status or attach.`);
+    console.error(`nixamp daemon: unknown action ${action}. Try start, restart, stop, status or attach.`);
     return 64;
 }
 /**
@@ -605,7 +621,11 @@ export function view({ ui, theme, height }, state) {
 }
 if (import.meta.main) {
     main().catch((error) => {
-        console.error(error);
+        // The same rule the installed launcher uses: a message we wrote is one the
+        // reader can act on, and printing a stack over it buries the sentence that
+        // says what to do.
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message.startsWith("nixamp:") ? message : error);
         process.exit(1);
     });
 }

package/dist/partyline.d.ts

@@ -134,15 +134,6 @@ export declare class PartyLine {
         add: (code: string, phone: string) => void;
         take: (code: string) => Promise<string[]>;
     }, waiting?: ReadonlyMap<string, ReadonlySet<string>>): void;
-    /**
-     * Legs listening to a stream, by its code.
-     *
-     * Separate from the rooms because a stream listener is not in a conference:
-     * they are a leg with an MP3 playing into it. Nothing else was counting
-     * them, so the directory had no way to say how many people were on the
-     * phone for a broadcast.
-     */
-    private readonly streamLegs;
     private readonly key;
     private readonly fetch;
     private readonly now;
@@ -199,6 +190,14 @@ export declare class PartyLine {
      * room code still works: this line was a party line before it was a way into
      * a broadcast, and a code that means nothing to the directory should still
      * mean a room.
+     *
+     * Keying a stream's code puts you in a room with the other people watching
+     * it. It does not play the stream at you, which is what it used to do: this
+     * is the phone line beside a broadcast, the way a podcast has an 800 number
+     * -- the show is on your screen and the phone is where you talk about it.
+     * Playing the audio down the phone was both the worse half of the idea and
+     * the one that kept failing, because a share link answers a 302 and a cookie
+     * rather than an MP3.
      */
     private stream;
     /** Whether the caller took the reminder that was offered. */
@@ -220,7 +219,13 @@ export declare class PartyLine {
     /** Put a leg into a room, making the conference if it is the first one there. */
     private join;
     private enter;
-    /** How many people are listening to a stream by phone. */
+    /**
+     * How many people are on the phone for a stream.
+     *
+     * The room's own count, now that a stream's code is a room like any other.
+     * It used to count legs with an MP3 playing into them, which is a thing that
+     * no longer happens.
+     */
     listenersOn(code: string): number;
     /** A leg that hung up or was dropped, wherever it was. */
     private release;

package/dist/partyline.js

@@ -155,15 +155,6 @@ export class PartyLine {
             this.reminders.set(code, set);
         }
     }
-    /**
-     * Legs listening to a stream, by its code.
-     *
-     * Separate from the rooms because a stream listener is not in a conference:
-     * they are a leg with an MP3 playing into it. Nothing else was counting
-     * them, so the directory had no way to say how many people were on the
-     * phone for a broadcast.
-     */
-    streamLegs = new Map();
     key;
     fetch;
     now;
@@ -318,6 +309,14 @@ export class PartyLine {
      * room code still works: this line was a party line before it was a way into
      * a broadcast, and a code that means nothing to the directory should still
      * mean a room.
+     *
+     * Keying a stream's code puts you in a room with the other people watching
+     * it. It does not play the stream at you, which is what it used to do: this
+     * is the phone line beside a broadcast, the way a podcast has an 800 number
+     * -- the show is on your screen and the phone is where you talk about it.
+     * Playing the audio down the phone was both the worse half of the idea and
+     * the one that kept failing, because a share link answers a 302 and a cookie
+     * rather than an MP3.
      */
     async stream(leg, code) {
         const streams = this.options.streams;
@@ -326,39 +325,12 @@ export class PartyLine {
         const live = streams.liveByCode(code);
         if (live !== undefined) {
             const what = live.nowPlaying ? ` of ${live.nowPlaying}` : "";
-            // The share link is not playable. It answers 302 with a cookie and sends
-            // a browser to the player page; Telnyx fetches once with no cookie jar
-            // and gets a 401 in JSON. Playing it means a caller who is told "here it
-            // is" and then hears nothing at all, which is how this was found. Say
-            // what is true instead, and hang up rather than bill for silence.
-            if (!live.audio) {
-                await this.command(leg, "speak", {
-                    payload: `${live.name} is live right now${what}, but this stream cannot be played over the phone. ` +
-                        "You can listen to it at nixamp dot com slash directory. Goodbye.",
-                    voice: this.voice,
-                });
-                await this.command(leg, "hangup", {});
-                this.options.onEvent?.(`  ${code} is live but announced no audio address; nothing to play.`);
-                return true;
-            }
             await this.command(leg, "speak", {
-                payload: `Welcome to ${live.name}'s live stream${what}. It started at ${pacificTime(live.startedAt)}. Here it is.`,
+                payload: `You're on the line for ${live.name}${what}. ` +
+                    "Everyone here is watching it too. Say hello.",
                 voice: this.voice,
             });
-            // A nixamp stream is an MP3 over HTTP and Telnyx will play a URL into a
-            // call, so listening by phone costs no audio handling here at all.
-            const playing = await this.command(leg, "playback_start", {
-                audio_url: live.audio,
-                loop: "infinity",
-            });
-            // Counted only once the audio is actually going. A leg we failed to
-            // start is not somebody listening, and the directory would be saying so.
-            if (playing) {
-                const legs = this.streamLegs.get(code) ?? new Set();
-                legs.add(leg);
-                this.streamLegs.set(code, legs);
-                this.options.onEvent?.(`  a caller is listening to ${code} (${legs.size} on the phone).`);
-            }
+            await this.join(leg, code);
             return true;
         }
         const ended = streams.endedByCode(code);
@@ -490,16 +462,18 @@ export class PartyLine {
         room.callers = room.legs.size;
         this.options.onEvent?.(`  a caller joined a room (${room.callers} on the line).`);
     }
-    /** How many people are listening to a stream by phone. */
+    /**
+     * How many people are on the phone for a stream.
+     *
+     * The room's own count, now that a stream's code is a room like any other.
+     * It used to count legs with an MP3 playing into them, which is a thing that
+     * no longer happens.
+     */
     listenersOn(code) {
-        return this.streamLegs.get(code)?.size ?? 0;
+        return this.rooms.get(code)?.callers ?? 0;
     }
     /** A leg that hung up or was dropped, wherever it was. */
     release(leg) {
-        for (const [code, legs] of this.streamLegs) {
-            if (legs.delete(leg) && legs.size === 0)
-                this.streamLegs.delete(code);
-        }
         const code = this.legRoom.get(leg);
         this.legRoom.delete(leg);
         if (code === undefined)

package/dist/server.d.ts

@@ -134,6 +134,16 @@ export declare function safeJoin(rootDir: string, urlPath: string): string | nul
  */
 export type Loaded = Track & {
     group?: string;
+    /**
+     * Whether this has a picture, when the name could not say.
+     *
+     * A file on disk is named `film.mkv` and that is answer enough. A live
+     * stream is `http://host/tipoffsport/KEY/301`, which says nothing at all --
+     * so it was treated as audio, transcoded with `-vn`, and arrived as a
+     * football match somebody could only listen to. Asked of ffprobe once, when
+     * the source is added, rather than guessed from a URL that has no opinion.
+     */
+    picture?: boolean;
 };
 /** What the HTTP layer needs from a player. Tests hand it a fake. */
 export interface Engine {
@@ -150,6 +160,8 @@ export interface Engine {
      * this server somewhere else", which throws the library away on purpose.
      */
     replace(tracks: Track[], root: string): void;
+    /** The library, arriving after the server was already listening. */
+    fill(tracks: Track[], root: string): void;
     /**
      * Play something as well as everything here.
      *
@@ -181,6 +193,14 @@ export interface Engine {
 }
 export declare function toRemoteTracks(tracks: Loaded[]): RemoteTrack[];
 export declare function hasPicture(path: string): boolean;
+/**
+ * Whether the name of a source tells us anything about what is inside it.
+ *
+ * A remote address with no extension -- an IPTV channel, a stream key, a
+ * redirect -- is the case where it does not, and the only way to find out is
+ * to look.
+ */
+export declare function nameSaysNothing(path: string): boolean;
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -252,6 +272,21 @@ export declare class PlayerEngine implements Engine {
      */
     drop(group: string): number;
     groups(): string[];
+    /**
+     * The library, arriving after the server was already listening.
+     *
+     * Walking a directory is the slow part of starting -- eighty thousand files
+     * under a home directory takes far longer than the fifteen seconds
+     * `nixamp daemon start` waits for the server to say it is up, so starting a
+     * daemon with no source given looked exactly like hanging and then failed
+     * about a server that was working. The port opens first now and this puts
+     * the library in behind it.
+     *
+     * Unlike `replace` it stops nothing and clears no listeners: whoever
+     * connected in the first second is still connected, and simply sees the
+     * playlist appear.
+     */
+    fill(tracks: Loaded[], root: string): void;
     retag(tracks: Track[], root: string): void;
 }
 /** An engine with no library behind it, for the hosted PWA. */
@@ -263,6 +298,7 @@ export declare class EmptyEngine implements Engine {
     subscribe(listener: (snapshot: Snapshot) => void): () => void;
     trackPath(): undefined;
     replace(): void;
+    fill(): void;
     add(): number;
     drop(): number;
     groups(): string[];
@@ -321,6 +357,18 @@ export interface HandlerOptions {
         destinations: Destination[];
         settings: EncoderSettings;
     };
+    /**
+     * Where OBS should point, one entry per stream this server will accept.
+     *
+     * There is deliberately no single link. ffmpeg's RTMP listener serves one
+     * connection per process, so three people going live at once is three ports
+     * and three URLs -- and a panel offering one address for all of them would
+     * be offering an address that works exactly once.
+     */
+    publishUrls?: () => {
+        id: string;
+        url: string;
+    }[];
     /** Accounts, on the instance that keeps them. Only nixamp.com passes this. */
     accounts?: Accounts;
     /** Providers to sign in with, and the terminals waiting to be connected. */