nixamp 0.18.0 → 0.19.0

package/dist/server.js

@@ -51,7 +51,7 @@ import { Catalogs, shownCatalog, shownEntry } from "./catalogs.js";
 import { Porkbun, isIPv4, isIPv6 } from "./dns.js";
 import { NameError, Names } from "./names.js";
 import { AcmeIssuer, Certs } from "./certs.js";
-import { claimName, fetchCert, labelFor, readCertFiles, writeCertFiles } from "./naming.js";
+import { claimName, fetchCert, humanizeSource, labelFor, readCertFiles, writeCertFiles } from "./naming.js";
 import { forbiddenLibrary, readLibrary } from "./library.js";
 import { createThrottle, presentedCredential } from "@profullstack/throttle";
 import { Durable } from "./durable.js";
@@ -880,7 +880,9 @@ export async function pullChannel(channels, ffprobe, id, name, source, input = [
     if (assumed)
         console.log(`  "${id}": the source would not say what it holds; carrying it as ${kind}.`);
     // A film has a length and a place to go back to; a live source has neither.
-    const live = known.live ?? !((codecs.duration ?? 0) > 0);
+    // A list is a station: joined where it is, and never seeked.
+    const playlist = known.playlist && known.playlist.length > 0 ? known.playlist : null;
+    const live = playlist ? true : (known.live ?? !((codecs.duration ?? 0) > 0));
     const encode = kind === "video"
         ? [
             // Which streams from which input, when there are two: the picture
@@ -896,12 +898,14 @@ export async function pullChannel(channels, ffprobe, id, name, source, input = [
     // the timestamps a recording cut mid-stream does not carry. Ahead of the
     // caller's own input arguments, which are headers for the address itself.
     const opening = [...transportInputArgs(source, codecs.container), ...input];
-    const channel = channels.pull(id, name, source, encode, kind, true, undefined, opening, kind === "video" ? audio : "", { live, position: known.position ?? 0 }, 
+    const channel = channels.pull(id, name, source, encode, kind, true, undefined, opening, kind === "video" ? audio : "", { live, position: known.position ?? 0, ...(playlist ? { playlist } : {}) }, 
     // Known before the first dial: whether the source is a transport stream
     // decides whether it can be read here for a source-boundary relay.
     assumed ? undefined : codecs);
     if (channel && !assumed)
         channel.info.codecs = codecs;
+    if (channel && playlist && known.playlistAt !== undefined)
+        channel.info.playlistAt = known.playlistAt;
     // What comes out, as opposed to what went in. An H.265 source copied
     // through stays H.265; one re-encoded arrives as H.264, and a packager
     // told otherwise would cut fMP4 segments for a stream that did not need
@@ -943,11 +947,16 @@ function shownLink(channelId, link, channel) {
         channel: channelId,
         name: channel?.name ?? link.title,
         live,
-        video: link.video,
+        // Whether there is a picture is the channel's answer where there is one:
+        // a list is guessed at as video until its first entry has been probed,
+        // and a station of podcasts opened a video element for nothing.
+        video: channel?.kind ? channel.kind !== "audio" : link.video,
         duration: link.duration,
         extractor: link.extractor,
         // A live has no whole to keep; a bare file can be fetched by the browser itself.
         download: !live && link.extractor !== "direct",
+        // How many things a list holds, for the page to say.
+        entries: link.playlist?.length ?? 0,
     };
 }
 export function liveOnes(engine) {
@@ -1057,14 +1066,15 @@ function htmlText(value) {
  *
  * Read from the page rather than hard-coded, because one NixAmp serves several
  * branded clients and each brings its own head. og:site_name first, then the
- * part of the title before the dash, then the hostname.
+ * part of the title before the dash or the colon ("nixamp: broadcast live
+ * radio..." is nixamp), then the hostname.
  */
 export function brandOf(shell, site) {
     const named = /<meta\s+property="og:site_name"\s+content="([^"]+)"/i.exec(shell);
     if (named?.[1])
         return named[1];
     const titled = /<title>([^<]*)<\/title>/i.exec(shell);
-    const head = titled?.[1]?.split(/\s[—-]\s/)[0]?.trim();
+    const head = titled?.[1]?.split(/\s[—-]\s|:\s/)[0]?.trim();
     if (head)
         return head;
     try {
@@ -1090,6 +1100,65 @@ function eventDocument(shell, event, site) {
         .replace(/<meta property="og:description" content="[^"]*"\s*\/>/, `<meta property="og:description" content="${htmlText(description)}" />`)
         .replace("</head>", `${event.visibility === "public" ? "" : '<meta name="robots" content="noindex,nofollow" />'}\n    <meta property="og:url" content="${htmlText(canonical)}" />\n    <link rel="canonical" href="${htmlText(canonical)}" />\n    <script type="application/ld+json">${structured}</script>\n  </head>`);
 }
+/**
+ * What a join link is for, named by something this server actually knows.
+ *
+ * A link preview reads the page before any script runs, so the shell has to
+ * say what is on the air. On the directory that is the listing the link
+ * points at, and the channel on it if one is asked for; on a server it is
+ * the server itself, or one of its channels. A name that only appears in the
+ * query is not used: a page that titled itself with whatever the address said
+ * would be a preview anyone could put words in.
+ */
+export function joinSubject(url, options) {
+    const play = url.searchParams.get("play") ?? "";
+    const wanted = play.startsWith("channel:") ? play.slice("channel:".length) : "";
+    const link = url.searchParams.get("url") ?? "";
+    if (options.directory) {
+        if (link === "")
+            return null;
+        const listings = options.directory.list();
+        const listing = listings.find((one) => one.url === link) ?? listings.find((one) => {
+            try {
+                return new URL(one.url).origin === new URL(link).origin;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!listing)
+            return null;
+        if (wanted !== "" && listing.channels.includes(wanted))
+            return { title: wanted, where: listing.name };
+        return { title: listing.name, where: "" };
+    }
+    // A link to somewhere else is that server's to name.
+    if (link !== "")
+        return null;
+    const name = options.serverName ?? "";
+    if (wanted !== "") {
+        const channel = options.channels?.list().find((one) => one.id === wanted || one.name === wanted);
+        return channel ? { title: channel.name, where: name } : null;
+    }
+    return name === "" ? null : { title: name, where: "" };
+}
+/** The shell, titled for what a join link opens. */
+export function joinDocument(shell, subject, site) {
+    const brand = brandOf(shell, site);
+    const shellTitle = /<title>([^<]*)<\/title>/i.exec(shell)?.[1] ?? "";
+    const title = `${subject.title} — ${brand}`;
+    const description = subject.where === ""
+        ? `${subject.title} is live on ${brand}. Tune in free, no account needed.`
+        : `${subject.title} is live on ${subject.where}. Tune in free on ${brand}, no account needed.`;
+    return shell
+        .replace(/<title>.*?<\/title>/s, `<title>${htmlText(title)}</title>`)
+        .replace(/<meta name="description" content="[^"]*"\s*\/>/, `<meta name="description" content="${htmlText(description)}" />`)
+        .replace(/<meta property="og:title" content="[^"]*"\s*\/>/, `<meta property="og:title" content="${htmlText(subject.title)}" />`)
+        .replace(/<meta property="og:description" content="[^"]*"\s*\/>/, `<meta property="og:description" content="${htmlText(description)}" />`)
+        // What the tab is called once the page takes over, so it does not stack
+        // the channel on a title that already names the channel.
+        .replace("</head>", `<meta name="nixamp-shell-title" content="${htmlText(shellTitle)}" />\n  </head>`);
+}
 function json(response, code, body) {
     const text = JSON.stringify(body);
     response.writeHead(code, {
@@ -2409,6 +2478,10 @@ export function createHandler(engine, options) {
                     // one nobody can dial is not worth showing.
                     code: state?.code ?? "",
                     url: state?.url ?? "",
+                    // Whether a link can go live here at all. The hosted directory
+                    // has no ffmpeg, and a page that offered to go live on it was
+                    // offering something that always failed.
+                    carries: options.carries !== false && Boolean(options.channels),
                 },
                 channels: (options.channels?.list() ?? []).map((one) => ({
                     id: one.id,
@@ -2425,6 +2498,8 @@ export function createHandler(engine, options) {
                     // How it has been going, for whoever may do something about it.
                     redials: one.redials ?? 0,
                     error: one.error ?? "",
+                    // For a list: how long it is, and which entry is on, from 0.
+                    ...(one.playlist ? { entries: one.playlist.length, entry: one.playlistAt ?? 0 } : {}),
                     // The member who put it on, when one did: theirs to take off.
                     startedBy: one.startedBy ?? "",
                 })),
@@ -2683,6 +2758,12 @@ export function createHandler(engine, options) {
                 json(response, 503, { error: "this server cannot carry channels" });
                 return;
             }
+            if (options.carries === false) {
+                json(response, 503, {
+                    error: `${options.serverName ?? "this server"} has no ffmpeg, so it cannot carry a link. Pick a server to go live on.`,
+                });
+                return;
+            }
             const channelId = linkChannelId(link);
             const known = links.get(link);
             // A member's is always a live: a decoder started on somebody else's
@@ -2756,7 +2837,7 @@ export function createHandler(engine, options) {
                     });
                     return;
                 }
-                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers), resolved.audio);
+                const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, resolved.title, resolved.media, inputArgsFor(resolved.headers), resolved.audio, resolved.playlist ? { playlist: resolved.playlist } : {});
                 if (!started) {
                     json(response, 409, { error: "that link is already starting" });
                     return;
@@ -3720,6 +3801,14 @@ export function createHandler(engine, options) {
                     }
                     catch { }
                 }
+                if (file.endsWith("index.html") && path === "/") {
+                    const subject = joinSubject(url, options);
+                    const shell = subject ? readIfPossible(file) : null;
+                    if (subject && shell !== null) {
+                        html(response, 200, joinDocument(shell, subject, options.invites?.site ?? "https://nixamp.com"));
+                        return;
+                    }
+                }
                 sendFile(request, response, file);
                 return;
             }
@@ -4089,6 +4178,9 @@ export async function serve(argv, version = "0.1.0") {
         throw new Error("nixamp serve: which folder? Say `nixamp library ~/Music` once, or `nixamp daemon start ~/Music`.");
     }
     const root = isRemote(chosen) ? chosen : resolve(chosen);
+    // What the stream is called where people see it: the name given, else the
+    // folder or playlist it was started on, in words, else this machine.
+    const streamName = options.name || humanizeSource(root) || hostname();
     const why = isRemote(root) ? "" : forbiddenLibrary(root);
     if (why) {
         throw new Error(`nixamp will not serve ${why}. Pick a folder with your media in it: nixamp library ~/Music`);
@@ -4186,6 +4278,7 @@ export async function serve(argv, version = "0.1.0") {
             ...(one.codecs ? { codecs: one.codecs } : {}),
             ...(one.position !== undefined ? { position: one.position } : {}),
             ...(one.live !== undefined ? { live: one.live } : {}),
+            ...(one.playlist ? { playlist: one.playlist, playlistAt: one.playlistAt ?? 0 } : {}),
         }).then((channel) => {
             if (!channel)
                 console.log(`  "${one.id}" is already on.`);
@@ -4198,7 +4291,8 @@ export async function serve(argv, version = "0.1.0") {
     let lastRemembered = "";
     setInterval(() => {
         const now = rememberedNow(channels);
-        if (!now.some((one) => one.position !== undefined))
+        // A list moves on without a position: which entry is on is the thing to keep.
+        if (!now.some((one) => one.position !== undefined || one.playlist))
             return;
         const text = JSON.stringify(now);
         if (text === lastRemembered)
@@ -4548,14 +4642,14 @@ export async function serve(argv, version = "0.1.0") {
         rememberChannels: remembering,
         catalogs,
         publishUrls: () => publishUrls,
-        serverName: options.name || hostname(),
+        serverName: streamName,
         homeSource: root,
         live: {
             status: () => ({
                 live: publisher !== null,
                 code: listing?.code ?? "",
                 channelCodes: listing?.channelCodes ?? {},
-                name: listing?.name ?? (options.name || hostname()),
+                name: listing?.name ?? streamName,
                 url: listing?.url ?? (publishable_ ? shareLink(publishable_.url, listenKey, false) : ""),
                 // Whether going live is even possible here. A laptop behind a router
                 // with no address the world can reach cannot be listed, and a button
@@ -4609,6 +4703,7 @@ export async function serve(argv, version = "0.1.0") {
         // A cookie jar beside the state, when the operator has put one there,
         // for the sites that will not talk to a datacenter without one.
         ytdlp: tools.ytdlp ?? null,
+        carries: tools.carries !== false,
         cookies: cookiesFile(),
         hls,
         compression,
@@ -4916,7 +5011,7 @@ export async function serve(argv, version = "0.1.0") {
         const audio = audioLink(publishable_.url, listenKey);
         return new Publisher({
             directory: DEFAULT_DIRECTORY,
-            name: options.name || hostname(),
+            name: streamName,
             url: listen,
             audio,
             // The control link, for the owner to open this machine as its

package/package.json

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

package/src/audio.ts

@@ -31,6 +31,12 @@ export interface Tools {
   play: string[] | null;
   /** yt-dlp, which turns a pasted page into a media address; null when there is none. */
   ytdlp?: string[] | null;
+  /**
+   * Whether an ffmpeg was actually found, as opposed to guessed at. A server
+   * without one cannot carry a channel, and should say so before a link is
+   * resolved and probed and blamed for it.
+   */
+  carries?: boolean;
 }
 
 function works(argv: string[], flag = "-version"): boolean {
@@ -112,6 +118,7 @@ export function detectTools(): Tools {
     ffprobe: ffprobe ?? ["ffprobe"],
     play,
     ytdlp,
+    carries: ffmpeg !== null,
   };
 }
 
@@ -439,7 +446,10 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
         ...rest,
         "-v", "quiet",
         "-print_format", "json",
-        "-show_entries", "format=format_name,duration:stream=codec_type,codec_name,width,height",
+        // The disposition too: an MP3 with its cover art in it carries that
+        // art as a video stream of one JPEG, and a probe that took it for a
+        // picture put a podcast on the air as a film with no frames.
+        "-show_entries", "format=format_name,duration:stream=codec_type,codec_name,width,height:stream_disposition=attached_pic",
         // A transport stream needs looking further into than a file with an
         // index does: there is no header listing the tracks, only packets, and
         // a 4K recording can carry a second of null padding and a long gap to
@@ -461,14 +471,17 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
     child.on("close", () => {
       try {
         const parsed = JSON.parse(out) as {
-          streams?: { codec_type?: string; codec_name?: string; width?: number; height?: number }[];
+          streams?: {
+            codec_type?: string; codec_name?: string; width?: number; height?: number;
+            disposition?: { attached_pic?: number };
+          }[];
           format?: { format_name?: string; duration?: string };
         };
         const streams = parsed.streams ?? [];
         // ffprobe prints seconds as a string, and "N/A" for a stream with no
         // end; both of those read as 0.
         const seconds = Number(parsed.format?.duration ?? 0);
-        const picture = streams.find((s) => s.codec_type === "video");
+        const picture = streams.find((s) => s.codec_type === "video" && !isCoverArt(s));
         return done({
           video: picture?.codec_name ?? "",
           audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
@@ -484,6 +497,22 @@ export async function codecsOf(tools: Tools, path: string, input: string[] = [])
   });
 }
 
+/**
+ * Cover art is not a picture.
+ *
+ * An MP3, FLAC or M4A with its sleeve embedded shows ffprobe a video stream:
+ * one JPEG or PNG, flagged as an attached picture. Carried as video it is a
+ * channel whose picture never gets a second frame -- ffmpeg writes nothing
+ * and the source is dialled again and again -- so a sleeve counts for
+ * nothing and the sound decides. A still-image codec with no such flag is
+ * the same thing from a container that does not flag it.
+ */
+const STILL_IMAGE = new Set(["png", "bmp", "gif", "tiff", "webp"]);
+export function isCoverArt(stream: { codec_name?: string; disposition?: { attached_pic?: number } }): boolean {
+  if (stream.disposition?.attached_pic === 1) return true;
+  return STILL_IMAGE.has((stream.codec_name ?? "").toLowerCase());
+}
+
 /** How much of a transport stream is read before deciding what is in it. */
 export const TRANSPORT_PROBE_BYTES = 20 * 1024 * 1024;
 export const TRANSPORT_ANALYSE_US = 10_000_000;

package/src/channels.ts

@@ -56,6 +56,14 @@ export interface ChannelInfo {
   error?: string;
   /** How many times the source has been dialled again since it started. */
   redials?: number;
+  /**
+   * For a channel that plays a list: the entries, in order, and which one is
+   * on. When one ends the next is dialled at once, and the last is followed
+   * by the first: a station, not a file. A restart picks up at the entry
+   * that was on.
+   */
+  playlist?: string[];
+  playlistAt?: number;
   /**
    * For a pulled film: how far into it we are, in seconds, read off ffmpeg
    * as it goes. This is what a restart and a redial go back to. A live
@@ -95,6 +103,8 @@ export interface PullResume {
   live: boolean;
   /** Seconds into a film to start from. */
   position: number;
+  /** For a list of things rather than one: every entry, in order. */
+  playlist?: string[];
 }
 
 /**
@@ -246,6 +256,8 @@ export class Channel {
   private fragments: Fragments | null = null;
   /** For a pulled channel: what to run, and how many times it has failed. */
   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;
   private failures = 0;
   private timer: ReturnType<typeof setTimeout> | null = null;
   /** Fires when a pulled source has said nothing for STALL. */
@@ -349,19 +361,37 @@ export class Channel {
     this.stall = stall;
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
-    const remote = /^https?:\/\//i.test(source);
     this.info.live = resume.live;
     if (!resume.live) this.info.position = Math.max(0, resume.position);
-    // What every remote input is told: dial again when the CDN drops it, and
-    // give up on a socket that has gone quiet. Input options apply to the
-    // input that follows them, so a second input is told again.
-    const remoteArgs = remote
-      ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
-      : [];
+    // 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;
+    let at = 0;
+    if (list) {
+      this.info.playlist = list;
+      at = Math.min(Math.max(0, this.info.playlistAt ?? 0), list.length - 1);
+      this.info.playlistAt = at;
+    }
+    let current = list ? (list[at] as string) : source;
+    this.advance = list && list.length > 1
+      ? () => {
+          at = (at + 1) % list.length;
+          this.info.playlistAt = at;
+          current = list[at] as string;
+          return true;
+        }
+      : null;
 
     const dial = (): void => {
       if (this.closing) return;
       this.stderr = "";
+      const remote = /^https?:\/\//i.test(current);
+      // What every remote input is told: dial again when the CDN drops it, and
+      // give up on a socket that has gone quiet. Input options apply to the
+      // input that follows them, so a second input is told again.
+      const remoteArgs = remote
+        ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5", "-rw_timeout", String(stall * 1000)]
+        : [];
       // Where to pick a film up from: a little before where it was, since
       // the place was written down a moment ago and a moment of it twice is
       // better than a moment of it missing. A live source is joined as is,
@@ -421,7 +451,7 @@ export class Channel {
                 // and a CDN that got them from yt-dlp and not from us answers 403.
                 ...input,
                 ...seek,
-                "-i", source,
+                "-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] : []),
@@ -584,13 +614,20 @@ export class Channel {
       this.close();
       return;
     }
-    this.info.redials = (this.info.redials ?? 0) + 1;
+    // A list moves on. An entry that played to its end is not a source that
+    // dropped: the next is dialled now, and it is not a redial. One that
+    // gave nothing is skipped the same way, counted as the failure it was,
+    // so a list of dead links gives up rather than cycling for ever.
+    const moved = this.advance?.() ?? false;
+    const ended = moved && sent;
+    if (ended) this.info.error = undefined;
+    else this.info.redials = (this.info.redials ?? 0) + 1;
     this.startOver();
     const dial = this.redial;
     this.timer = setTimeout(() => {
       this.timer = null;
       dial();
-    }, REDIAL);
+    }, ended ? 0 : REDIAL);
     // A redial is not a reason to keep the process alive at exit.
     this.timer.unref?.();
   }
@@ -1171,6 +1208,9 @@ export interface RememberedChannel {
   live?: boolean;
   /** The member who put it on, so it is still theirs after a restart. */
   startedBy?: string;
+  /** For a list: every entry, and which was on, so it carries on from there. */
+  playlist?: string[];
+  playlistAt?: number;
 }
 
 const REMEMBERED = "channels.json";
@@ -1207,6 +1247,11 @@ export function rememberedChannels(dir: string, port: number): RememberedChannel
         if (typeof one["position"] === "number" && Number.isFinite(one["position"]) && one["position"] > 0) kept.position = one["position"];
         if (typeof one["live"] === "boolean") kept.live = one["live"];
         if (typeof one["startedBy"] === "string" && one["startedBy"] !== "") kept.startedBy = one["startedBy"];
+        if (Array.isArray(one["playlist"])) {
+          const entries = (one["playlist"] as unknown[]).filter((entry): entry is string => typeof entry === "string" && entry !== "");
+          if (entries.length > 0) kept.playlist = entries;
+          if (typeof one["playlistAt"] === "number" && Number.isInteger(one["playlistAt"]) && one["playlistAt"] >= 0) kept.playlistAt = one["playlistAt"];
+        }
         return kept;
       });
   } catch {
@@ -1230,6 +1275,10 @@ export function rememberedNow(channels: Channels): RememberedChannel[] {
       if (typeof one.live === "boolean") kept.live = one.live;
       if (!one.live && typeof one.position === "number" && one.position > 0) kept.position = Math.floor(one.position);
       if (one.startedBy) kept.startedBy = one.startedBy;
+      if (one.playlist && one.playlist.length > 0) {
+        kept.playlist = one.playlist;
+        kept.playlistAt = one.playlistAt ?? 0;
+      }
       return kept;
     });
 }

package/src/links.ts

@@ -21,6 +21,7 @@
  */
 import { createHash } from "node:crypto";
 import { spawn } from "node:child_process";
+import { parseCatalog } from "./catalogs.ts";
 
 export interface ResolvedLink {
   /** What to call it: the page's title, or the file's name for a bare file. */
@@ -50,6 +51,12 @@ export interface ResolvedLink {
   ext: string;
   /** The page it came from. */
   page: string;
+  /**
+   * For a pasted .m3u: every entry in it, in order. The channel plays them
+   * one after another and starts over at the end, a station rather than a
+   * file; `media` is the first, for the probe that decides what it holds.
+   */
+  playlist?: string[];
 }
 
 /**
@@ -71,6 +78,86 @@ export function isDirectMedia(url: string): boolean {
   }
 }
 
+/**
+ * A plain m3u: a list of things to play, one per line, which is not a thing
+ * ffmpeg reads. The .m3u8 of HLS is a list of segments of one thing, which
+ * it does, and stays in DIRECT above.
+ */
+const PLAYLIST = /\.m3u(\?.*)?$/i;
+
+export function isPlaylistLink(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    return PLAYLIST.test(parsed.pathname + parsed.search);
+  } catch {
+    return false;
+  }
+}
+
+/** How much of a playlist is worth reading: a list, not a library dump. */
+export const PLAYLIST_MAX_BYTES = 2_000_000;
+export const PLAYLIST_MAX_ENTRIES = 1000;
+export const PLAYLIST_FETCH_TIMEOUT_MS = 15_000;
+
+/**
+ * What a playlist's text holds: the entries, in order, resolved against
+ * where the list was fetched from. Some things called .m3u are HLS after
+ * all -- a segment list with #EXT-X- tags -- and those are one stream for
+ * ffmpeg to read as it is, not a list of streams.
+ */
+export function playlistFrom(text: string, base: string): { hls: boolean; sources: string[] } {
+  if (/^#EXT-X-/m.test(text)) return { hls: true, sources: [] };
+  const sources = parseCatalog(text, base)
+    .map((entry) => entry.source)
+    .filter((source) => /^(https?|rtmps?):\/\//i.test(source))
+    .slice(0, PLAYLIST_MAX_ENTRIES);
+  return { hls: false, sources };
+}
+
+/**
+ * A pasted .m3u, read and turned into a channel's worth of entries. Fetched
+ * here rather than by yt-dlp, which would take the first entry and stop, or
+ * by ffmpeg, which does not read a plain list at all.
+ */
+export async function resolvePlaylist(
+  url: string,
+  options: { timeoutMs?: number; fetcher?: typeof fetch } = {},
+): Promise<ResolvedLink | { error: string }> {
+  const get = options.fetcher ?? fetch;
+  const abort = new AbortController();
+  const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? PLAYLIST_FETCH_TIMEOUT_MS);
+  let text = "";
+  try {
+    const answer = await get(url, { signal: abort.signal, headers: { "user-agent": "nixamp" }, redirect: "follow" });
+    if (!answer.ok) return { error: `that playlist could not be fetched (HTTP ${answer.status})` };
+    text = (await answer.text()).slice(0, PLAYLIST_MAX_BYTES);
+  } catch (error) {
+    const why = abort.signal.aborted ? "took too long to answer" : ((error as Error).message || "could not be fetched");
+    return { error: `that playlist ${why}` };
+  } finally {
+    clearTimeout(timer);
+  }
+  const list = playlistFrom(text, url);
+  if (list.hls) return directLink(url);
+  const [first] = list.sources;
+  if (!first) return { error: "that playlist has nothing in it this can play" };
+  return {
+    title: fileNameOf(url).replace(/\.m3u$/i, "") || "Playlist",
+    media: first,
+    audio: "",
+    // A station: joined where it is, never seeked, and with no end to save.
+    live: true,
+    duration: 0,
+    // Whether there is a picture is the first entry's to say; ffprobe settles it.
+    video: true,
+    headers: {},
+    extractor: "playlist",
+    ext: "",
+    page: url,
+    playlist: list.sources,
+  };
+}
+
 /** A link somebody pasted, or "" when it is not one this can play. */
 export function playableLink(entered: unknown): string {
   if (typeof entered !== "string") return "";
@@ -313,6 +400,7 @@ export async function resolveLink(
   options: { cookies?: string; timeoutMs?: number; format?: string } = {},
 ): Promise<ResolvedLink | { error: string }> {
   if (isDirectMedia(url)) return directLink(url);
+  if (isPlaylistLink(url)) return resolvePlaylist(url, { timeoutMs: options.timeoutMs });
   // Without yt-dlp, a link is taken as the media it may well be: an IPTV
   // feed has no extension and no page behind it, and ffprobe -- asked next,
   // before anything goes on the air -- tells a stream from a web page in a

package/src/naming.ts

@@ -195,3 +195,44 @@ export function labelFor(name: string, hostname: string): string {
   }
   return "server";
 }
+
+/** File endings that name a playlist rather than a folder, dropped from a title. */
+const PLAYLIST_ENDING = /\.(m3u8?|pls|xspf|txt|json)$/i;
+
+/**
+ * What to call a stream that was started on a path, for people.
+ *
+ * `nixamp serve ~/Music/live-sets_2024` used to be listed as the machine's
+ * hostname, which tells a stranger nothing. The last segment of the path is
+ * what the person who made the folder called it, so that is the title: the
+ * separators that a filesystem forces become spaces, a playlist loses its
+ * ending, and each lowercase word gets a capital. Words with a capital in
+ * them already are left alone, so "DJ" and "LoFi" stay as written, and a
+ * dash or dot between two digits stays too, so a date is still a date.
+ * Empty when the path has no segment worth saying, and the caller falls
+ * back to whatever it used before.
+ */
+export function humanizeSource(source: string): string {
+  const remote = /^[a-z][a-z0-9+.-]*:\/\//i.test(source);
+  let last = "";
+  try {
+    const path = remote ? new URL(source).pathname : source;
+    last = path.split("/").filter(Boolean).pop() ?? "";
+    if (remote) last = decodeURIComponent(last);
+  } catch {
+    return "";
+  }
+  if (last === "" || last === "~" || last === ".") return "";
+  const words = last
+    .replace(PLAYLIST_ENDING, "")
+    .replace(/(?<!\d)[-_.+]+|[-_.+]+(?!\d)/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  if (words === "") return "";
+  return words
+    .split(" ")
+    .map((word) => (word === word.toLowerCase() ? word.charAt(0).toUpperCase() + word.slice(1) : word))
+    .join(" ")
+    .slice(0, 60)
+    .trim();
+}