nixamp 0.7.36 → 0.7.37

package/dist/channels.d.ts

@@ -198,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,6 +16,8 @@
  */
 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;
@@ -529,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/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();
@@ -1857,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;
             }
@@ -1927,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;
             }
@@ -2810,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
@@ -2994,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.36",
+  "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/channels.ts

@@ -16,6 +16,8 @@
  */
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import type { Readable } from "node:stream";
 import { Fragments } from "./fragments.ts";
 
@@ -599,6 +601,59 @@ export class Channels {
   }
 }
 
+/**
+ * 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;
+}
+
+const REMEMBERED = "channels.json";
+
+export function rememberedChannels(dir: string, port: number): RememberedChannel[] {
+  try {
+    const all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8")) as Record<string, unknown>;
+    const list = all[String(port)];
+    if (!Array.isArray(list)) return [];
+    return list.filter(
+      (one): one is RememberedChannel =>
+        typeof one === "object" && one !== null &&
+        typeof (one as RememberedChannel).id === "string" &&
+        typeof (one as RememberedChannel).name === "string" &&
+        typeof (one as RememberedChannel).source === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+export function rememberChannels(dir: string, port: number, list: RememberedChannel[]): void {
+  let all: Record<string, unknown> = {};
+  try {
+    all = JSON.parse(readFileSync(join(dir, REMEMBERED), "utf8")) as Record<string, unknown>;
+  } 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(): string {
   return `s${randomBytes(3).toString("hex")}`;

package/src/server.ts

@@ -26,7 +26,10 @@ import {
   redact,
 } from "./broadcast.ts";
 import { Ingest, normaliseFormat } from "./ingest.ts";
-import { Channels, cleanId, generatedId } from "./channels.ts";
+import {
+  Channels, cleanId, generatedId, rememberChannels, rememberedChannels,
+  type Channel, type RememberedChannel,
+} from "./channels.ts";
 import { RtmpListeners } from "./rtmp-in.ts";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.ts";
 import { anonymousHandle, Handles } from "./handles.ts";
@@ -908,6 +911,30 @@ export 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 async function pullChannel(
+  channels: Channels,
+  ffprobe: string[],
+  id: string,
+  name: string,
+  source: string,
+): Promise<Channel | null> {
+  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: Engine): { name: string; at: number; tracks: number }[] {
   const tracks = engine.snapshot().tracks ?? [];
   const found = new Map<string, { name: string; at: number; tracks: number }>();
@@ -1065,6 +1092,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. */
@@ -2260,6 +2289,15 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         // 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 as string })),
+          );
+        }
         json(response, stopped ? 200 : 404, { ok: stopped });
         return;
       }
@@ -2335,20 +2373,20 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           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 as string })),
+            { id: wanted, name: called, source },
+          ]);
+        }
         json(response, 200, { ok: true, channel: channel.info });
         return;
       }
@@ -3279,6 +3317,17 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     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: RememberedChannel[]): void => 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
@@ -3479,6 +3528,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     media: options.media,
     owner,
     channels,
+    rememberChannels: remembering,
     publishUrls: () => publishUrls,
     serverName: options.name || hostname(),
     homeSource: root,

package/web/dist/install.sh

@@ -98,6 +98,22 @@ BASE="${NIXAMP_RELEASE_BASE:-https://github.com/$REPO/releases/download/v$VERSIO
 SHARE="$PREFIX/share/nixamp"
 BIN="$PREFIX/bin"
 
+# --- a daemon already running here --------------------------------------------
+#
+# Noticed now, restarted at the end. An update used to leave the old version
+# running until somebody remembered to restart it, and restarting it by hand
+# from the wrong directory started a server of your home folder over plain
+# http. `nixamp daemon restart` replays the flags the daemon was started with,
+# so the installer runs that rather than guessing at any.
+STATE_DIR="${XDG_STATE_HOME:-$HOME/.local/state}/nixamp"
+DAEMON_PID=""
+if [ -r "$STATE_DIR/daemon.json" ]; then
+  DAEMON_PID=$(sed -n 's/^[[:space:]]*"pid":[[:space:]]*\([0-9][0-9]*\).*/\1/p' "$STATE_DIR/daemon.json" | head -n 1)
+  if [ -n "$DAEMON_PID" ] && ! kill -0 "$DAEMON_PID" 2>/dev/null; then
+    DAEMON_PID=""
+  fi
+fi
+
 say "nixamp $VERSION"
 say "  platform:  $OS-$ARCH"
 say "  desktop:   $WANT_DESKTOP"
@@ -219,7 +235,7 @@ else
   RUNTIME=""
 
   command -v node >/dev/null 2>&1 ||
-    say "  note: no desktop app was installed, so the CLI needs Node 24 or newer. It was not found."
+    say "  note: no desktop app was installed, so the CLI needs Node 22.6 or newer, and none is on PATH."
 fi
 
 # The shim. Written here rather than shipped, because only the installer knows
@@ -236,7 +252,7 @@ else
 #!/bin/sh
 # nixamp. Written by the installer; \`nixamp uninstall\` removes it.
 command -v node >/dev/null 2>&1 || {
-  echo "nixamp: node 24 or newer is required for a CLI-only install." >&2
+  echo "nixamp: node is not on PATH. This install runs on your own Node (22.6 or newer)." >&2
   exit 69
 }
 NIXAMP_HOME="$SHARE" exec node "$CLI_DIR/bin/nixamp.mjs" "\$@"
@@ -362,6 +378,17 @@ elif [ "$FW_RESULT" = manual ]; then
   say "  Open it with:  $(firewall_command)"
 fi
 
+if [ -n "$DAEMON_PID" ]; then
+  say ""
+  say "A nixamp daemon was running (pid $DAEMON_PID). Restarting it on $VERSION,"
+  say "with the flags it was started with..."
+  if "$BIN/nixamp" daemon restart; then
+    say "  Restarted. The channels it was carrying come back on their own."
+  else
+    say "  Could not restart it. Run:  nixamp daemon restart"
+  fi
+fi
+
 case ":$PATH:" in
   *":$BIN:"*)
     say ""

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1789030337931";
+const CACHE = "nixamp-1789031044115";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",