nixamp 0.28.45 → 0.30.1

package/dist/stations.js

@@ -0,0 +1,331 @@
+/**
+ * Stations: a collection turned into a program that keeps playing.
+ *
+ * A channel is a running decoder, named for what it plays, and gone when it
+ * stops. A station is the thing a person made and named: which files, in what
+ * rotation, who may hear it, and whether it should be on. Its id is random
+ * and never changes, so its link survives a rename, a restart, a moved file
+ * and a renderer that died; the channel it plays through (`station-<id>`) is
+ * only how it happens to be delivered right now.
+ *
+ * Two states, kept apart. `desired` is what the owner asked for and is
+ * written down; a station deliberately stopped stays stopped after a restart,
+ * and one left running comes back. `observed` is what is actually happening
+ * and is never written down, because it is only true now.
+ *
+ * Who may listen is the station's own business, not the server's. A new
+ * station is private, stopped and unlisted. Its listen token opens its stream,
+ * its now-playing and its picture, and nothing of the library behind it.
+ * Listing it in the public directory is a separate choice from making it
+ * public, and making it public asks first on what basis it may be broadcast.
+ */
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { mkdirSync, readFileSync, realpathSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+export const RIGHTS_BASES = ["owned", "permission", "licensed", "public-domain"];
+/** Times an item may fail in a row before rotation leaves it out. */
+export const EXCLUDE_AFTER = 3;
+export const DEFAULT_BITRATE = 128;
+export const BITRATES = [64, 96, 128, 160, 192, 256, 320];
+const MAX_ITEMS = 20_000;
+const MAX_NAME = 120;
+const MAX_DESCRIPTION = 500;
+/** A station's channel id. */
+export function channelOf(id) {
+    return `station-${id}`;
+}
+/** The station a channel id belongs to, or "" for any other channel. */
+export function stationOfChannel(channelId) {
+    return channelId.startsWith("station-") ? channelId.slice("station-".length) : "";
+}
+function newId() {
+    // Ten characters of base32: short enough to read out, far too many to guess.
+    const alphabet = "abcdefghijkmnpqrstuvwxyz23456789";
+    return [...randomBytes(10)].map((byte) => alphabet[byte % alphabet.length]).join("");
+}
+function newToken() {
+    return randomBytes(16).toString("base64url");
+}
+export function tokensMatch(offered, held) {
+    const a = Buffer.from(offered);
+    const b = Buffer.from(held);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/** A path inside one of these roots, after symlinks: never outside the library. */
+export function insideRoots(path, roots) {
+    let real;
+    try {
+        real = realpathSync(path);
+    }
+    catch {
+        return false;
+    }
+    return roots.some((root) => {
+        let base;
+        try {
+            base = realpathSync(root);
+        }
+        catch {
+            return false;
+        }
+        return real === base || real.startsWith(base.endsWith(sep) ? base : base + sep);
+    });
+}
+export class StationError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+}
+function text(value, max, field) {
+    if (typeof value !== "string")
+        throw new StationError("invalid_" + field, `${field} must be text`);
+    return value.trim().replace(/[\u0000-\u001f\u007f]/g, " ").slice(0, max);
+}
+/** The stations of one server, kept in one file beside its keys. */
+export class StationStore {
+    file;
+    io;
+    stations = new Map();
+    constructor(file, io = {
+        read: (path) => { try {
+            return readFileSync(path, "utf8");
+        }
+        catch {
+            return null;
+        } },
+        write: (path, body) => {
+            mkdirSync(dirname(path), { recursive: true });
+            const temporary = `${path}.${process.pid}.tmp`;
+            writeFileSync(temporary, body, { mode: 0o600 });
+            renameSync(temporary, path);
+        },
+    }) {
+        this.file = file;
+        this.io = io;
+        const body = this.io.read(file);
+        if (body === null)
+            return;
+        try {
+            const parsed = JSON.parse(body);
+            for (const one of parsed.stations ?? []) {
+                if (one && typeof one.id === "string" && Array.isArray(one.items)) {
+                    this.stations.set(one.id, {
+                        ...one,
+                        failures: one.failures ?? {},
+                        bitrate: one.bitrate ?? DEFAULT_BITRATE,
+                        rights: one.rights ?? null,
+                        owner: one.owner ?? "",
+                        description: one.description ?? "",
+                        idempotencyKey: one.idempotencyKey ?? "",
+                    });
+                }
+            }
+        }
+        catch {
+            // A file that cannot be read is not a reason to refuse to serve. It is
+            // left where it is, and the next write replaces it.
+        }
+    }
+    static fileFor(stateDir, port) {
+        return join(stateDir, `stations-${port}.json`);
+    }
+    save() {
+        this.io.write(this.file, `${JSON.stringify({ version: 1, stations: [...this.stations.values()] }, null, 2)}\n`);
+    }
+    list() {
+        return [...this.stations.values()].sort((a, b) => a.createdAt - b.createdAt);
+    }
+    get(id) {
+        return this.stations.get(id);
+    }
+    /** New, and always private, stopped and unlisted (RAD-02). */
+    /** The station a create with this key already made. */
+    byIdempotencyKey(key) {
+        if (key === "")
+            return undefined;
+        return [...this.stations.values()].find((one) => one.idempotencyKey === key);
+    }
+    create(input, items, owner, now = Date.now(), idempotencyKey = "") {
+        const name = text(input.name ?? "", MAX_NAME, "name");
+        if (name === "")
+            throw new StationError("name_required", "a station needs a name");
+        if (items.length === 0)
+            throw new StationError("empty_station", "choose at least one file that plays");
+        if (items.length > MAX_ITEMS)
+            throw new StationError("too_many_items", `a station holds at most ${MAX_ITEMS} files`);
+        const station = {
+            id: newId(),
+            name,
+            description: input.description === undefined ? "" : text(input.description, MAX_DESCRIPTION, "description"),
+            items,
+            shuffle: input.shuffle === true,
+            repeat: input.repeat !== false,
+            visibility: "private",
+            listed: false,
+            desired: "stopped",
+            listenToken: newToken(),
+            bitrate: this.bitrateFrom(input.bitrate),
+            rights: null,
+            owner,
+            failures: {},
+            idempotencyKey: idempotencyKey.slice(0, 200),
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.stations.set(station.id, station);
+        this.save();
+        return station;
+    }
+    bitrateFrom(value) {
+        if (value === undefined)
+            return DEFAULT_BITRATE;
+        if (typeof value !== "number" || !BITRATES.includes(value)) {
+            throw new StationError("invalid_bitrate", `bitrate is one of ${BITRATES.join(", ")} kbps`);
+        }
+        return value;
+    }
+    /** Name, words, files and rotation. Who may listen is changed by publish/unpublish. */
+    update(id, input, items, now = Date.now()) {
+        const station = this.require(id);
+        if (input.name !== undefined) {
+            const name = text(input.name, MAX_NAME, "name");
+            if (name === "")
+                throw new StationError("name_required", "a station needs a name");
+            station.name = name;
+        }
+        if (input.description !== undefined)
+            station.description = text(input.description, MAX_DESCRIPTION, "description");
+        if (input.shuffle !== undefined)
+            station.shuffle = input.shuffle === true;
+        if (input.repeat !== undefined)
+            station.repeat = input.repeat !== false;
+        if (input.bitrate !== undefined)
+            station.bitrate = this.bitrateFrom(input.bitrate);
+        if (items !== null) {
+            if (items.length === 0)
+                throw new StationError("empty_station", "a station needs at least one file that plays");
+            if (items.length > MAX_ITEMS)
+                throw new StationError("too_many_items", `a station holds at most ${MAX_ITEMS} files`);
+            station.items = items;
+            // A file taken out and put back is given another chance.
+            station.failures = Object.fromEntries(Object.entries(station.failures).filter(([file]) => items.includes(file)));
+        }
+        station.updatedAt = now;
+        this.save();
+        return station;
+    }
+    remove(id) {
+        const had = this.stations.delete(id);
+        if (had)
+            this.save();
+        return had;
+    }
+    setDesired(id, desired, now = Date.now()) {
+        const station = this.require(id);
+        station.desired = desired;
+        station.updatedAt = now;
+        this.save();
+        return station;
+    }
+    /**
+     * Who may hear it, and whether the directory lists it. Public needs a
+     * declared basis; listed needs public. Going private mints a new token, so
+     * every link handed out before stops working, and the caller drops the
+     * listeners who used one.
+     */
+    setAccess(id, access, by, now = Date.now()) {
+        const station = this.require(id);
+        const visibility = access.visibility === undefined ? station.visibility : access.visibility;
+        if (visibility !== "private" && visibility !== "unlisted" && visibility !== "public") {
+            throw new StationError("invalid_visibility", "visibility is private, unlisted or public");
+        }
+        let listed = access.listed === undefined ? station.listed : access.listed === true;
+        if (visibility !== "public")
+            listed = false;
+        if (access.rights) {
+            const basis = access.rights.basis;
+            if (typeof basis !== "string" || !RIGHTS_BASES.includes(basis)) {
+                throw new StationError("invalid_rights_basis", `the basis is one of ${RIGHTS_BASES.join(", ")}`);
+            }
+            station.rights = {
+                basis: basis,
+                note: access.rights.note === undefined ? "" : text(access.rights.note, MAX_DESCRIPTION, "note"),
+                declaredAt: now,
+                declaredBy: by,
+            };
+        }
+        if (visibility === "public" && station.rights === null) {
+            throw new StationError("rights_required", "before a station is public, say on what basis it may be broadcast: owned, permission, licensed or public-domain", 409);
+        }
+        const revoked = visibility === "private" && station.visibility !== "private";
+        station.visibility = visibility;
+        station.listed = listed;
+        if (revoked)
+            station.listenToken = newToken();
+        station.updatedAt = now;
+        this.save();
+        return { station, revoked };
+    }
+    /** A new listen link; every earlier one stops working. */
+    rotateToken(id, now = Date.now()) {
+        const station = this.require(id);
+        station.listenToken = newToken();
+        station.updatedAt = now;
+        this.save();
+        return station;
+    }
+    /** One more failure in a row for this file; true when it is now left out. */
+    recordFailure(id, file) {
+        const station = this.stations.get(id);
+        if (!station)
+            return false;
+        const count = (station.failures[file] ?? 0) + 1;
+        station.failures[file] = count;
+        this.save();
+        return count === EXCLUDE_AFTER;
+    }
+    /** Played through: its failures are forgotten. */
+    recordSuccess(id, file) {
+        const station = this.stations.get(id);
+        if (!station || station.failures[file] === undefined)
+            return;
+        delete station.failures[file];
+        this.save();
+    }
+    /** Every left-out file tried again (the owner's "retry"). */
+    clearFailures(id) {
+        const station = this.require(id);
+        station.failures = {};
+        this.save();
+        return station;
+    }
+    isExcluded(id, file) {
+        return (this.stations.get(id)?.failures[file] ?? 0) >= EXCLUDE_AFTER;
+    }
+    require(id) {
+        const station = this.stations.get(id);
+        if (!station)
+            throw new StationError("not_found", "no such station", 404);
+        return station;
+    }
+}
+/** A station-wide shuffle: one order for everybody, Fisher-Yates. */
+export function shuffled(length, random = Math.random) {
+    const order = [...Array(length).keys()];
+    for (let index = order.length - 1; index > 0; index--) {
+        const other = Math.floor(random() * (index + 1));
+        [order[index], order[other]] = [order[other], order[index]];
+    }
+    return order;
+}
+/**
+ * Restart after an unexpected end: 2 s, doubling, at most a minute apart.
+ * After the last of these the station is offline but still wanted, and is
+ * tried again every OFFLINE_RETRY_MS so a source that comes back is found.
+ */
+export const RECOVERY_DELAYS_MS = [2_000, 4_000, 8_000, 16_000, 32_000, 60_000];
+export const OFFLINE_RETRY_MS = 5 * 60_000;

package/package.json

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

package/src/audio.ts

@@ -6,6 +6,7 @@
  * same bytes to the output process. Running two decoders instead would drift
  * apart within seconds and the bars would stop matching what you hear.
  */
+import { protocolArgs } from "./decoder-policy.ts";
 import { spawn, spawnSync, type ChildProcess } from "node:child_process";
 import { readdirSync } from "node:fs";
 import { homedir } from "node:os";
@@ -136,6 +137,7 @@ export function probe(tools: Tools, path: string): Track {
     ...rest,
     "-v", "quiet", "-print_format", "json",
     "-show_format", "-show_entries", "format_tags=title,artist,album",
+    ...protocolArgs(path),
     path,
   ], { encoding: "utf8", timeout: 20_000, maxBuffer: 4 * 1024 * 1024 });
   if (result.error || result.status !== 0) return fallback;
@@ -224,6 +226,7 @@ export class Stream {
       // being on disk. Measured with that condition in place: still 13.8x.
       "-re",
       ...(from > 0 ? ["-ss", String(from)] : []),
+      ...protocolArgs(track.path),
       "-i", track.path,
       "-f", "f32le", "-ac", String(CHANNELS), "-ar", String(RATE), "-",
     ], { stdio: ["ignore", "pipe", "pipe"] });

package/src/channels.ts

@@ -14,11 +14,12 @@
  * what live means. MP3 frames are self-describing, so a player finds the next
  * frame boundary and carries on; there is nothing to catch up on.
  */
+import { protocolArgs } from "./decoder-policy.ts";
 import { spawn, type ChildProcess } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { PlaylistInputStream } from "./playlist-input.ts";
+import { PlaylistInputStream, type PlaylistInput } from "./playlist-input.ts";
 import type { Readable } from "node:stream";
 import { FragmentClock, Fragments, isOpening } from "./fragments.ts";
 
@@ -122,6 +123,13 @@ export interface PullResume {
   /** For a list of things rather than one: every entry, in order. */
   playlist?: string[];
   playlistAt?: number;
+  /**
+   * How a station plays its list: round and round, in a shuffled order, with
+   * edits landing on the next track and broken entries passed over. Only for
+   * lists of files on this machine; not remembered, because whoever owns the
+   * rotation (the station) puts it back.
+   */
+  rotation?: Pick<PlaylistInput, "repeat" | "order" | "current" | "excluded" | "onFailure" | "passOver">;
 }
 
 /**
@@ -284,6 +292,13 @@ export class Channel {
   private redial: (() => void) | null = null;
   /** For a channel playing a list: move to the next entry. Null when there is no list. */
   private advance: (() => boolean) | null = null;
+  /** The list being played entry by entry, when it is one; what skip() moves on. */
+  private playlistInput: PlaylistInputStream | null = null;
+
+  /** On to the next entry of a list of files. False when this is not one. */
+  skip(): boolean {
+    return this.playlistInput?.skip() ?? false;
+  }
   private failures = 0;
   private timer: ReturnType<typeof setTimeout> | null = null;
   /** Fires when a pulled source has said nothing for STALL. */
@@ -400,7 +415,7 @@ export class Channel {
     // A list plays entry by entry: the one that is on is what gets dialled,
     // and an entry that ended is followed by the next, at once.
     const list = resume.playlist && resume.playlist.length > 0 ? resume.playlist : null;
-    const localPlaylist = list && list.length > 1 && list.every(one => !/^https?:\/\//i.test(one)) ? list : null;
+    const localPlaylist = list && (list.length > 1 || resume.rotation) && list.every(one => !/^https?:\/\//i.test(one)) ? list : null;
     let at = 0;
     if (list) {
       this.info.playlist = list;
@@ -450,7 +465,9 @@ export class Channel {
         ffprobe: this.options.ffprobe ?? this.options.ffmpeg.map(one => one.replace(/ffmpeg(?=(?:\.exe)?$)/, "ffprobe")),
         files: localPlaylist, at: this.info.playlistAt ?? 0, position: from,
         video: this.info.kind === "video", width: this.info.codecs?.width, height: this.info.codecs?.height,
+        ...resume.rotation,
       }) : null;
+      this.playlistInput = playlistInput;
       const through = this.outroOn ? null : playlistInput
         ? { format: "mpegts", open: async (signal: AbortSignal) => playlistInput.open(signal) }
         : this.options.through?.(this.info, from, input, audio) ?? null;
@@ -503,10 +520,10 @@ export class Channel {
                 // What the source's site expects on the request: a user agent, a
                 // referer, a cookie. A link resolved by yt-dlp comes with these,
                 // and a CDN that got them from yt-dlp and not from us answers 403.
-                ...input, ...seek, "-i", current,
+                ...input, ...seek, ...protocolArgs(current), "-i", current,
                 // The sound, when the site keeps it apart from the picture: a
                 // second input, dialled the same way, that the encode maps in.
-                ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, "-i", audio] : []),
+                ...(audio ? [...remoteArgs, ...(paced ? ["-re"] : []), ...input, ...seek, ...protocolArgs(audio), "-i", audio] : []),
               ]),
           ...(playlistEncode ?? encode),
           "pipe:1",
@@ -1324,6 +1341,11 @@ export class Channels {
     return this.open.get(id)?.info.kind;
   }
 
+  /** The next entry, now, on a channel playing a list of files. */
+  skip(id: string): boolean {
+    return this.open.get(id)?.skip() ?? false;
+  }
+
   stop(id: string): boolean {
     const channel = this.open.get(id);
     if (!channel) return false;
@@ -1434,7 +1456,10 @@ export function rememberedChannels(dir: string, port: number): RememberedChannel
  */
 export function rememberedNow(channels: Channels): RememberedChannel[] {
   return channels.list()
-    .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id))
+    // A station's channel is put back by its station, which knows whether it
+    // is still wanted; remembering it here too would bring back one its
+    // owner had stopped.
+    .filter((one) => one.via === "pull" && one.source && !channels.isEphemeral(one.id) && !one.id.startsWith("station-"))
     .map((one) => {
       const kept: RememberedChannel = { id: one.id, name: one.name, source: one.source as string };
       if (one.kind) kept.kind = one.kind;

package/src/decoder-policy.ts

@@ -0,0 +1,33 @@
+/**
+ * What a decoder may open while reading one source.
+ *
+ * ffmpeg follows references inside what it reads: an .m3u8 names segments, a
+ * concat list names files, a playlist on disk can name a URL. A file in
+ * somebody's library is untrusted input, and without a list of protocols it
+ * can make this machine fetch any address it likes, on the LAN included. So
+ * a file on disk may open files and pipes and nothing else, and a link may
+ * open the network protocols a stream needs and not the local file system.
+ *
+ * Sources this does not recognise (an ingest URL, a lavfi graph) are left
+ * alone rather than broken: the list is for what comes out of a library or a
+ * pasted link, which is where untrusted references come from.
+ */
+
+/** A file in a library: itself, and the pipes the pipeline is built from. */
+export const LOCAL_PROTOCOLS = "file,pipe,fd";
+
+/** A link: the network, as streams use it, and never `file`. */
+export const REMOTE_PROTOCOLS = [
+  "http", "https", "tcp", "tls", "crypto", "data", "httpproxy",
+  "rtmp", "rtmps", "rtmpt", "rtmpts", "rtmpe", "rtmpte", "ffrtmpcrypt", "ffrtmphttp",
+].join(",");
+
+/** The `-protocol_whitelist` to put before this source's `-i`, or nothing. */
+export function protocolArgs(source: string): string[] {
+  if (source === "-" || source.startsWith("pipe:")) return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+  if (/^(https?|rtmp[a-z]*):\/\//i.test(source)) return ["-protocol_whitelist", REMOTE_PROTOCOLS];
+  if (/^file:/i.test(source)) return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+  // Any other scheme (two letters or more, so `C:\` is still a path).
+  if (/^[a-z][a-z0-9+.-]+:/i.test(source)) return [];
+  return ["-protocol_whitelist", LOCAL_PROTOCOLS];
+}

package/src/destinations.ts

@@ -0,0 +1,78 @@
+/**
+ * Whether a link somebody else pasted may be fetched from this machine.
+ *
+ * A member -- any nixamp.com account -- may put a link on the air on a server
+ * that is not theirs. Fetching it is a request from inside the owner's
+ * network, so a link to the router, the cloud metadata address or a service
+ * on localhost would be the member reaching things only the owner can. The
+ * owner may fetch what they like: it is their network. A member's link has to
+ * resolve to a public address, every address it resolves to, at every hop
+ * this code follows.
+ *
+ * What it cannot see: a redirect yt-dlp or ffmpeg follows on its own, and a
+ * name that resolves differently a second later. The decoder's protocol list
+ * (decoder-policy.ts) keeps those off the file system; keeping them off the
+ * LAN entirely needs the fetch to happen here, which is later work.
+ */
+import { lookup as dnsLookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+export type Lookup = (host: string) => Promise<string[]>;
+
+const defaultLookup: Lookup = async (host) =>
+  (await dnsLookup(host, { all: true, verbatim: true })).map((one) => one.address);
+
+function v4Number(address: string): number {
+  return address.split(".").reduce((sum, part) => sum * 256 + Number(part), 0);
+}
+
+function inV4(address: string, base: string, bits: number): boolean {
+  const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+  return ((v4Number(address) & mask) >>> 0) === ((v4Number(base) & mask) >>> 0);
+}
+
+const PRIVATE_V4: Array<[string, number]> = [
+  ["0.0.0.0", 8], ["10.0.0.0", 8], ["100.64.0.0", 10], ["127.0.0.0", 8],
+  ["169.254.0.0", 16], ["172.16.0.0", 12], ["192.0.0.0", 24], ["192.0.2.0", 24],
+  ["192.168.0.0", 16], ["198.18.0.0", 15], ["198.51.100.0", 24], ["203.0.113.0", 24],
+  ["224.0.0.0", 4], ["240.0.0.0", 4],
+];
+
+/** Not somewhere on the public internet: loopback, private, link-local, reserved. */
+export function isPrivateAddress(address: string): boolean {
+  const kind = isIP(address);
+  if (kind === 4) return PRIVATE_V4.some(([base, bits]) => inV4(address, base, bits));
+  if (kind !== 6) return true;
+  const lower = address.toLowerCase();
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(lower);
+  if (mapped) return isPrivateAddress(mapped[1]!);
+  if (lower === "::" || lower === "::1") return true;
+  const first = parseInt(lower.split(":")[0] || "0", 16);
+  // fc00::/7 unique local, fe80::/10 link-local, ff00::/8 multicast.
+  if ((first & 0xfe00) === 0xfc00) return true;
+  if ((first & 0xffc0) === 0xfe80) return true;
+  if ((first & 0xff00) === 0xff00) return true;
+  return false;
+}
+
+/** "" when this link may be fetched for a member, else why not. */
+export async function refusedDestination(link: string, lookup: Lookup = defaultLookup): Promise<string> {
+  let url: URL;
+  try {
+    url = new URL(link);
+  } catch {
+    return "that is not a link";
+  }
+  if (!/^(https?|rtmps?):$/i.test(url.protocol)) return "only http, https and rtmp links can be played here";
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (host === "" || /^localhost$/i.test(host) || /\.localhost$/i.test(host)) return "that link points at this machine";
+  let addresses: string[];
+  try {
+    addresses = isIP(host) ? [host] : await lookup(host);
+  } catch {
+    return "that link's host does not resolve";
+  }
+  if (addresses.length === 0) return "that link's host does not resolve";
+  if (addresses.some(isPrivateAddress)) return "that link points inside a private network, which only this server's owner may play";
+  return "";
+}

package/src/directory.ts

@@ -154,6 +154,8 @@ export interface LineupEntry {
   kind: "audio" | "video";
   art: string;
   about: string;
+  /** A station's own listening page, on the same server; only for a station its owner listed. */
+  listen?: string;
 }
 
 const MAX_NAME = 60;
@@ -233,13 +235,13 @@ export function parseAnnouncement(input: unknown): Announcement | null {
         }
       : {}),
     ...(Array.isArray(record["lineup"])
-      ? { lineup: (record["lineup"] as unknown[]).map(parseLineupEntry).filter((one): one is LineupEntry => one !== null).slice(0, MAX_CHANNELS) }
+      ? { lineup: (record["lineup"] as unknown[]).map((one) => parseLineupEntry(one, listen.origin)).filter((one): one is LineupEntry => one !== null).slice(0, MAX_CHANNELS) }
       : {}),
   };
 }
 
 /** One lineup entry as a publisher sent it, cleaned, or null when it is not one. */
-export function parseLineupEntry(input: unknown): LineupEntry | null {
+export function parseLineupEntry(input: unknown, origin = ""): LineupEntry | null {
   if (typeof input !== "object" || input === null) return null;
   const record = input as Record<string, unknown>;
   const id = clean(record["id"], MAX_ID);
@@ -257,6 +259,12 @@ export function parseLineupEntry(input: unknown): LineupEntry | null {
     // page in a tag, and javascript: is a page in a tag that runs.
     art: publishable(art) !== null ? art : "",
     about: clean(record["about"], MAX_ABOUT),
+    // The same server as the listing, or nothing, like the audio address.
+    ...(() => {
+      const offered = typeof record["listen"] === "string" ? record["listen"].slice(0, MAX_ART) : "";
+      const parsed = offered && origin ? publishable(offered) : null;
+      return parsed !== null && parsed.origin === origin ? { listen: offered } : {};
+    })(),
   };
 }
 

package/src/library.ts

@@ -23,6 +23,8 @@ import { stateDir } from "./daemon.ts";
 export interface Config {
   /** The folder the daemon serves when it is not told which. */
   library?: string;
+  /** Whether this machine is listed in the public directory; unset until chosen. */
+  publish?: boolean;
 }
 
 export function configPath(): string {
@@ -34,7 +36,10 @@ export function readConfig(): Config {
     const parsed = JSON.parse(readFileSync(configPath(), "utf8")) as unknown;
     if (typeof parsed !== "object" || parsed === null) return {};
     const record = parsed as Record<string, unknown>;
-    return { ...(typeof record["library"] === "string" ? { library: record["library"] } : {}) };
+    return {
+      ...(typeof record["library"] === "string" ? { library: record["library"] } : {}),
+      ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
+    };
   } catch {
     return {};
   }