nixamp 0.7.35 → 0.7.37

package/dist/audio.js

@@ -190,7 +190,9 @@ export class Stream {
             this.output.stdin?.on("error", () => { });
         }
         let stderr = "";
-        this.decoder.stderr?.on("data", (c) => { stderr += c.toString(); });
+        // The tail only: what went wrong is on the last line, and a film with a
+        // damaged audio track can say so once a frame for two hours.
+        this.decoder.stderr?.on("data", (c) => { stderr = (stderr + c.toString()).slice(-2000); });
         this.decoder.stdout?.on("data", (chunk) => {
             if (this.stopped || generation !== this.generation)
                 return;

package/dist/channels.d.ts

@@ -23,11 +23,23 @@ export interface ChannelInfo {
     kind?: "audio" | "video";
     /** For a channel we pull ourselves: where from. Never shown to a listener. */
     source?: string;
+    /** The last thing ffmpeg complained about, for whoever administers this. */
+    error?: string;
+    /** How many times the source has been dialled again since it started. */
+    redials?: number;
 }
 /** How long to wait before dialling a dropped source again. */
 export declare const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
 export declare const GIVE_UP = 5;
+/**
+ * How long a pulled source may say nothing before it is treated as gone.
+ *
+ * ffmpeg's own reconnect covers a connection that errors. It does not cover
+ * one that simply stops sending, and neither does anything else: a television
+ * channel that is quiet for half a minute is not being quiet, it is dead.
+ */
+export declare const STALL = 30000;
 /** A name that can sit in a URL and be read back in a list. */
 export declare function cleanId(value: unknown, fallback?: string): string;
 export interface ChannelOptions {
@@ -54,6 +66,10 @@ export declare class Channel {
     private redial;
     private failures;
     private timer;
+    /** Fires when a pulled source has said nothing for STALL. */
+    private watchdog;
+    private stall;
+    private stderr;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**
@@ -69,7 +85,33 @@ export declare class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source: string, encode: string[], paced?: boolean): void;
+    pull(source: string, encode: string[], paced?: boolean, stall?: number): void;
+    /**
+     * Start the source over, now.
+     *
+     * For a pulled channel only: a publisher's stream cannot be dialled again
+     * from this end. The current ffmpeg is killed and a new one started at
+     * once, with the count of failures cleared -- somebody asking for this has
+     * decided the thing is worth another go, and should not inherit the four
+     * strikes a dead CDN ran up an hour ago.
+     */
+    restart(): boolean;
+    /**
+     * The stream that was is over; the next ffmpeg is a new one.
+     *
+     * New opening boxes, timestamps from zero again. Whoever was listening
+     * cannot follow that mid-picture, and a newcomer must not be handed the old
+     * opening boxes in front of the new fragments -- so the header is dropped
+     * and the audience is ended, to come back to the stream as it now is. The
+     * player rejoins on its own. Done the moment the source is known to be
+     * gone, not when the redial happens: somebody joining in between gets the
+     * new beginning as it is written, rather than a stale one first.
+     */
+    private startOver;
+    /** Expect output within STALL, or treat the source as gone and dial again. */
+    private rearm;
+    /** End everybody listening; the stream they were on is over. */
+    private hangUp;
     /**
      * A source that stopped. Try it again, unless it never worked at all.
      *
@@ -130,7 +172,15 @@ export declare class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean): Channel | null;
+    pull(id: string, name: string, source: string, encode: string[], kind: "audio" | "video", paced?: boolean, stall?: number): Channel | null;
+    /**
+     * Dial a pulled channel's source again, now. False for a channel that is
+     * not there or is not ours to dial: a publisher's stream restarts at the
+     * publisher's end.
+     */
+    restart(id: string): boolean;
+    /** Whether a channel is one we fetch ourselves, and so can start over. */
+    pulled(id: string): boolean;
     /** What a listener should be told this channel is. */
     contentType(id: string): string;
     /** Attach a listener, or null when nothing is playing on that channel. */
@@ -148,5 +198,24 @@ export declare class Channels {
     stop(id: string): boolean;
     stopAll(): void;
 }
+/**
+ * The channels a server pulls itself, remembered across a restart.
+ *
+ * A server is restarted to pick up a new version, which is to say often, and
+ * every restart used to take CNN off the air until somebody noticed and put
+ * it back by hand. A publisher's stream cannot be remembered -- it restarts at
+ * the publisher's end -- but a pulled one is a name and a URL, and a name and
+ * a URL can be written down.
+ *
+ * Keyed by port, like the keys, because two servers on one machine are two
+ * different line-ups.
+ */
+export interface RememberedChannel {
+    id: string;
+    name: string;
+    source: string;
+}
+export declare function rememberedChannels(dir: string, port: number): RememberedChannel[];
+export declare function rememberChannels(dir: string, port: number, list: RememberedChannel[]): void;
 /** A channel id nobody chose, for a publisher that did not name one. */
 export declare function generatedId(): string;

package/dist/channels.js

@@ -16,11 +16,47 @@
  */
 import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { Fragments } from "./fragments.js";
 /** How long to wait before dialling a dropped source again. */
 export const REDIAL = 2000;
 /** How many times in a row a source may fail without ever sending anything. */
 export const GIVE_UP = 5;
+/**
+ * How long a pulled source may say nothing before it is treated as gone.
+ *
+ * ffmpeg's own reconnect covers a connection that errors. It does not cover
+ * one that simply stops sending, and neither does anything else: a television
+ * channel that is quiet for half a minute is not being quiet, it is dead.
+ */
+export const STALL = 30_000;
+/** How much of what ffmpeg said to keep, for the last line when it dies. */
+const TAIL = 2000;
+/**
+ * Read everything a child says on stderr, keeping only the end of it.
+ *
+ * This is not optional. A pipe nobody reads fills, at 64 KiB on Linux, and
+ * the child then blocks on its next write to it -- every thread it has waits
+ * on the one that is stuck, and it produces nothing more, for ever, without
+ * exiting. A channel carrying an IPTV transport stream logs a line for every
+ * corrupt packet, and over twelve hours that is more than 64 KiB. Measured on
+ * the real server: CNN "on the air" with a full stderr socket, its decoder
+ * thread asleep in the kernel on that write, its byte count frozen, and a
+ * listener handed the opening boxes and then nothing at all.
+ */
+function drain(stream, keep) {
+    let tail = "";
+    stream?.on("data", (chunk) => {
+        tail = (tail + chunk.toString("utf8")).slice(-TAIL);
+        keep(tail);
+    });
+    stream?.on("error", () => undefined);
+}
+/** The last thing ffmpeg said, which is where it says what went wrong. */
+function lastLine(tail) {
+    return tail.trim().split("\n").pop() ?? "";
+}
 /** A name that can sit in a URL and be read back in a list. */
 export function cleanId(value, fallback = "main") {
     if (typeof value !== "string")
@@ -47,6 +83,10 @@ export class Channel {
     redial = null;
     failures = 0;
     timer = null;
+    /** Fires when a pulled source has said nothing for STALL. */
+    watchdog = null;
+    stall = STALL;
+    stderr = "";
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -72,6 +112,7 @@ export class Channel {
             this.info.bytes += chunk.byteLength;
             this.send(chunk);
         });
+        drain(child.stderr, (tail) => { this.stderr = tail; });
         // A publisher that hangs up mid-write breaks the pipe, and an unhandled
         // EPIPE takes the whole server with it.
         child.stdin?.on("error", () => this.close());
@@ -94,7 +135,8 @@ export class Channel {
      * because you looked away, and a room where the picture depends on who is
      * in it is not a room anybody can be invited to.
      */
-    pull(source, encode, paced = true) {
+    pull(source, encode, paced = true, stall = STALL) {
+        this.stall = stall;
         if (this.info.kind === "video")
             this.fragments = new Fragments();
         const [command, ...prefix] = this.options.ffmpeg;
@@ -102,6 +144,7 @@ export class Channel {
         const dial = () => {
             if (this.closing)
                 return;
+            this.stderr = "";
             const child = spawn(command, [
                 ...prefix,
                 "-hide_banner",
@@ -110,6 +153,11 @@ export class Channel {
                 // the first time a CDN hiccups is not a channel anybody can rely
                 // on. ffmpeg redials on its own before we have to.
                 ...(remote ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
+                // A connection that stops answering is an error after this long,
+                // and an error is a thing the reconnect above knows what to do
+                // with. Without it a silent socket is waited on for ever. In
+                // microseconds, as ffmpeg wants it.
+                ...(remote ? ["-rw_timeout", String(stall * 1000)] : []),
                 // Real time, always. A file read as fast as the disk allows is an
                 // hour of film in ninety seconds and a room that cannot be in it
                 // together; a live source is already paced and loses nothing.
@@ -119,20 +167,102 @@ export class Channel {
                 "pipe:1",
             ], { stdio: ["ignore", "pipe", "pipe"] });
             let sent = false;
+            this.child = child;
+            this.rearm(child);
             child.stdout?.on("data", (chunk) => {
+                // An ffmpeg that was replaced can still have a chunk in the pipe.
+                if (this.child !== child)
+                    return;
                 sent = true;
                 this.info.bytes += chunk.byteLength;
+                this.rearm(child);
                 this.emit(chunk);
             });
             child.stdout?.on("error", () => undefined);
-            child.on("error", () => this.dropped(sent));
-            child.on("close", () => this.dropped(sent));
-            this.child = child;
+            drain(child.stderr, (tail) => { this.stderr = tail; });
+            // Only the ffmpeg we are currently running gets to say the source
+            // dropped. One that was killed to make way for a restart is not news.
+            child.on("error", () => { if (this.child === child)
+                this.dropped(sent); });
+            child.on("close", () => { if (this.child === child)
+                this.dropped(sent); });
         };
         this.redial = dial;
         dial();
         this.options.onStart?.(this.info);
     }
+    /**
+     * Start the source over, now.
+     *
+     * For a pulled channel only: a publisher's stream cannot be dialled again
+     * from this end. The current ffmpeg is killed and a new one started at
+     * once, with the count of failures cleared -- somebody asking for this has
+     * decided the thing is worth another go, and should not inherit the four
+     * strikes a dead CDN ran up an hour ago.
+     */
+    restart() {
+        const dial = this.redial;
+        if (!dial || this.closing)
+            return false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        this.failures = 0;
+        this.info.redials = (this.info.redials ?? 0) + 1;
+        this.info.error = undefined;
+        const old = this.child;
+        this.child = null;
+        old?.kill("SIGKILL");
+        this.startOver();
+        dial();
+        return true;
+    }
+    /**
+     * The stream that was is over; the next ffmpeg is a new one.
+     *
+     * New opening boxes, timestamps from zero again. Whoever was listening
+     * cannot follow that mid-picture, and a newcomer must not be handed the old
+     * opening boxes in front of the new fragments -- so the header is dropped
+     * and the audience is ended, to come back to the stream as it now is. The
+     * player rejoins on its own. Done the moment the source is known to be
+     * gone, not when the redial happens: somebody joining in between gets the
+     * new beginning as it is written, rather than a stale one first.
+     */
+    startOver() {
+        if (this.info.kind === "video")
+            this.fragments = new Fragments();
+        this.hangUp();
+    }
+    /** Expect output within STALL, or treat the source as gone and dial again. */
+    rearm(child) {
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = setTimeout(() => {
+            this.watchdog = null;
+            if (this.child !== child || this.closing)
+                return;
+            this.info.error = `no data from the source for ${Math.round(this.stall / 1000)}s`;
+            // Its close handler is what dials again.
+            child.kill("SIGKILL");
+        }, this.stall);
+        this.watchdog.unref?.();
+    }
+    /** End everybody listening; the stream they were on is over. */
+    hangUp() {
+        for (const listener of this.listeners) {
+            try {
+                listener.end();
+            }
+            catch {
+                // Gone already.
+            }
+        }
+        this.listeners.clear();
+        this.info.listeners = 0;
+    }
     /**
      * A source that stopped. Try it again, unless it never worked at all.
      *
@@ -144,11 +274,19 @@ export class Channel {
         if (this.closing || !this.redial)
             return;
         this.child = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        const said = lastLine(this.stderr);
+        if (said)
+            this.info.error = said;
         this.failures = sent ? 0 : this.failures + 1;
         if (this.failures >= GIVE_UP) {
             this.close();
             return;
         }
+        this.info.redials = (this.info.redials ?? 0) + 1;
+        this.startOver();
         const dial = this.redial;
         this.timer = setTimeout(() => {
             this.timer = null;
@@ -234,6 +372,12 @@ export class Channel {
         if (this.timer)
             clearTimeout(this.timer);
         this.timer = null;
+        if (this.watchdog)
+            clearTimeout(this.watchdog);
+        this.watchdog = null;
+        const said = lastLine(this.stderr);
+        if (said && !this.info.error)
+            this.info.error = said;
         const child = this.child;
         this.child = null;
         try {
@@ -318,7 +462,7 @@ export class Channels {
      * about it is the same too, which is the point -- a re-stream stops being a
      * special case and becomes one more thing that is on.
      */
-    pull(id, name, source, encode, kind, paced = true) {
+    pull(id, name, source, encode, kind, paced = true, stall = STALL) {
         if (this.open.has(id))
             return null;
         const channel = new Channel({
@@ -333,9 +477,21 @@ export class Channels {
             source,
         }, this.options, (gone) => this.open.delete(gone));
         this.open.set(id, channel);
-        channel.pull(source, encode, paced);
+        channel.pull(source, encode, paced, stall);
         return channel;
     }
+    /**
+     * Dial a pulled channel's source again, now. False for a channel that is
+     * not there or is not ours to dial: a publisher's stream restarts at the
+     * publisher's end.
+     */
+    restart(id) {
+        return this.open.get(id)?.restart() ?? false;
+    }
+    /** Whether a channel is one we fetch ourselves, and so can start over. */
+    pulled(id) {
+        return this.open.get(id)?.info.via === "pull";
+    }
     /** What a listener should be told this channel is. */
     contentType(id) {
         return this.open.get(id)?.info.kind === "video" ? "video/mp4" : "audio/mpeg";
@@ -375,6 +531,39 @@ export class Channels {
             channel.close();
     }
 }
+const REMEMBERED = "channels.json";
+export function rememberedChannels(dir, port) {
+    try {
+        const all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8"));
+        const list = all[String(port)];
+        if (!Array.isArray(list))
+            return [];
+        return list.filter((one) => typeof one === "object" && one !== null &&
+            typeof one.id === "string" &&
+            typeof one.name === "string" &&
+            typeof one.source === "string");
+    }
+    catch {
+        return [];
+    }
+}
+export function rememberChannels(dir, port, list) {
+    let all = {};
+    try {
+        all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8"));
+    }
+    catch {
+        // First time, or unreadable: start again rather than refuse to remember.
+    }
+    all[String(port)] = list;
+    try {
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, REMEMBERED), JSON.stringify(all, null, 2));
+    }
+    catch {
+        // A state directory that cannot be written costs a memory, not a stream.
+    }
+}
 /** A channel id nobody chose, for a publisher that did not name one. */
 export function generatedId() {
     return `s${randomBytes(3).toString("hex")}`;

package/dist/rtmp-in.js

@@ -59,6 +59,10 @@ export class RtmpListeners {
             channel?.feed(chunk);
         });
         child.stdout?.on("error", () => child.kill("SIGKILL"));
+        // Read and dropped. A pipe nobody reads fills at 64 KiB, and ffmpeg then
+        // blocks on its next complaint and stops producing anything -- a
+        // publisher whose stream hiccups enough would take the slot down with it.
+        child.stderr?.resume();
         child.on("error", () => this.done(slot, child, channel));
         child.on("close", () => this.done(slot, child, channel));
     }

package/dist/server.d.ts

@@ -2,7 +2,7 @@ import { type IncomingMessage, type Server, type ServerResponse } from "node:htt
 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 { Channels, type Channel, type RememberedChannel } from "./channels.ts";
 import { Accounts } from "./accounts.ts";
 import { Handles } from "./handles.ts";
 import { OpenDirs } from "./opendirs.ts";
@@ -336,6 +336,14 @@ export declare class PlayerEngine implements Engine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * Probe a source and start carrying it as a channel of its own.
+ *
+ * Shared by the request that puts one on and the boot that puts remembered
+ * ones back, so that both agree on what a source is encoded as. Null when
+ * that channel id is already on.
+ */
+export declare function pullChannel(channels: Channels, ffprobe: string[], id: string, name: string, source: string): Promise<Channel | null>;
 export declare function liveOnes(engine: Engine): {
     name: string;
     at: number;
@@ -403,6 +411,8 @@ export interface HandlerOptions {
     ingest?: Ingest;
     /** Several live streams at once, each with its own audience. */
     channels?: Channels;
+    /** Write down the channels this server pulls, so a restart puts them back. */
+    rememberChannels?: (list: RememberedChannel[]) => void;
     /** Live audio going out to RTMP. */
     broadcaster?: Broadcaster;
     /** Where a broadcast should send, and what it should look like. */

package/dist/server.js

@@ -19,7 +19,7 @@ import { readFileSync } from "node:fs";
 import { Connections } from "./connections.js";
 import { Broadcaster, DEFAULT_ENCODER, PRESETS, redact, } from "./broadcast.js";
 import { Ingest, normaliseFormat } from "./ingest.js";
-import { Channels, cleanId, generatedId } from "./channels.js";
+import { Channels, cleanId, generatedId, rememberChannels, rememberedChannels, } from "./channels.js";
 import { RtmpListeners } from "./rtmp-in.js";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.js";
 import { anonymousHandle, Handles } from "./handles.js";
@@ -707,6 +707,23 @@ export class PlayerEngine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * Probe a source and start carrying it as a channel of its own.
+ *
+ * Shared by the request that puts one on and the boot that puts remembered
+ * ones back, so that both agree on what a source is encoded as. Null when
+ * that channel id is already on.
+ */
+export async function pullChannel(channels, ffprobe, id, name, source) {
+    const codecs = await codecsOf({ ffmpeg: [], ffprobe, play: null }, source);
+    const kind = codecs.video === "" ? "audio" : "video";
+    const encode = kind === "video"
+        ? videoArgs(codecs)
+        // No picture in it, so none is invented: MP3 is the thing every browser
+        // plays and the thing a listener can join halfway through.
+        : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
+    return channels.pull(id, name, source, encode, kind);
+}
 export function liveOnes(engine) {
     const tracks = engine.snapshot().tracks ?? [];
     const found = new Map();
@@ -1774,6 +1791,12 @@ export function createHandler(engine, options) {
                     via: one.via,
                     listeners: one.listeners,
                     startedAt: one.startedAt,
+                    // Whether it has a picture, so the page puts it in the element
+                    // that can show one. Never the source: that is the owner's.
+                    kind: one.kind ?? "audio",
+                    // How it has been going, for whoever may do something about it.
+                    redials: one.redials ?? 0,
+                    error: one.error ?? "",
                 })),
                 // Anything re-streamed into this server is a live stream too, and was
                 // sitting in the middle of the playlist among the files -- which is
@@ -1797,7 +1820,13 @@ export function createHandler(engine, options) {
         // devices can publish at once, each to their own channel, and a listener
         // picks which to hear.
         if (path === "/api/channels" && options.channels) {
-            json(response, 200, { channels: options.channels.list(), listeners: options.channels.listeners });
+            // Without the source. Anyone holding the listen link may ask what is
+            // on, and the address a channel is pulled from is the one thing about
+            // it that is not theirs to have.
+            json(response, 200, {
+                channels: options.channels.list().map(({ source: _source, ...shown }) => shown),
+                listeners: options.channels.listeners,
+            });
             return;
         }
         // Publishing. Anyone with the control link may; listening to the result is
@@ -1845,6 +1874,13 @@ export function createHandler(engine, options) {
                 // Asked once: the second call would answer false, having just stopped
                 // the thing it was asking about.
                 const stopped = channels.stop(id);
+                // Taken off on purpose is forgotten on purpose: it must not come back
+                // at the next restart.
+                if (stopped && options.rememberChannels) {
+                    options.rememberChannels(channels.list()
+                        .filter((one) => one.via === "pull" && one.source)
+                        .map((one) => ({ id: one.id, name: one.name, source: one.source })));
+                }
                 json(response, stopped ? 200 : 404, { ok: stopped });
                 return;
             }
@@ -1852,6 +1888,27 @@ export function createHandler(engine, options) {
                 json(response, 405, { error: "GET, POST or DELETE" });
                 return;
             }
+            /**
+             * Dial the source again, now.
+             *
+             * The thing an administrator reaches for when a channel says it is on
+             * the air and shows nobody anything. It is what fixed CNN by hand --
+             * take it off, put it back -- without having to know the source, which
+             * a browser is never told.
+             */
+            if (action === "restart") {
+                if (!channels.has(id)) {
+                    json(response, 404, { error: "nothing is playing on that channel" });
+                    return;
+                }
+                if (!channels.pulled(id)) {
+                    json(response, 409, { error: "that channel is published into this server; restart it at the publisher" });
+                    return;
+                }
+                const restarted = channels.restart(id);
+                json(response, restarted ? 200 : 409, { ok: restarted });
+                return;
+            }
             /**
              * Carry a source of our own, rather than waiting to be sent one.
              *
@@ -1894,19 +1951,20 @@ export function createHandler(engine, options) {
                     json(response, 409, { error: "that channel is already on" });
                     return;
                 }
-                const probe = options.ffprobe ?? ["ffprobe"];
-                const codecs = await codecsOf({ ffmpeg: [], ffprobe: probe, play: null }, source);
-                const kind = codecs.video === "" ? "audio" : "video";
-                const encode = kind === "video"
-                    ? videoArgs(codecs)
-                    // No picture in it, so none is invented: MP3 is the thing every
-                    // browser plays and the thing a listener can join halfway through.
-                    : ["-vn", "-c:a", "libmp3lame", "-b:a", "192k", "-f", "mp3"];
-                const channel = channels.pull(wanted, called, source, encode, kind);
+                const channel = await pullChannel(channels, options.ffprobe ?? ["ffprobe"], wanted, called, source);
                 if (!channel) {
                     json(response, 409, { error: "that channel is already on" });
                     return;
                 }
+                // Written down, so a restart puts it back on the air.
+                if (options.rememberChannels) {
+                    options.rememberChannels([
+                        ...channels.list()
+                            .filter((one) => one.via === "pull" && one.source && one.id !== wanted)
+                            .map((one) => ({ id: one.id, name: one.name, source: one.source })),
+                        { id: wanted, name: called, source },
+                    ]);
+                }
                 json(response, 200, { ok: true, channel: channel.info });
                 return;
             }
@@ -2777,6 +2835,17 @@ export async function serve(argv, version = "0.1.0") {
         onStart: (info) => console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
         onEnd: (info) => console.log(`  "${info.id}" stopped.`),
     });
+    // The channels this server was carrying when it was last stopped, put back
+    // on. A server is restarted to pick up a new version, which is often, and
+    // every restart used to take CNN off the air until somebody noticed.
+    const remembering = (list) => rememberChannels(stateDir(), options.port, list);
+    for (const one of rememberedChannels(stateDir(), options.port)) {
+        console.log(`  Putting "${one.id}" (${one.name}) back on the air.`);
+        void pullChannel(channels, tools.ffprobe, one.id, one.name, one.source).then((channel) => {
+            if (!channel)
+                console.log(`  "${one.id}" is already on.`);
+        });
+    }
     const destinations = parseDestinations(options.rtmp);
     const broadcaster = new Broadcaster(tools.ffmpeg);
     const ingest = options.ingest
@@ -2961,6 +3030,7 @@ export async function serve(argv, version = "0.1.0") {
         media: options.media,
         owner,
         channels,
+        rememberChannels: remembering,
         publishUrls: () => publishUrls,
         serverName: options.name || hostname(),
         homeSource: root,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.7.35",
+  "version": "0.7.37",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/audio.ts

@@ -218,7 +218,9 @@ export class Stream {
     }
 
     let stderr = "";
-    this.decoder.stderr?.on("data", (c: Buffer) => { stderr += c.toString(); });
+    // The tail only: what went wrong is on the last line, and a film with a
+    // damaged audio track can say so once a frame for two hours.
+    this.decoder.stderr?.on("data", (c: Buffer) => { stderr = (stderr + c.toString()).slice(-2000); });
 
     this.decoder.stdout?.on("data", (chunk: Buffer) => {
       if (this.stopped || generation !== this.generation) return;