nixamp 0.7.4 → 0.7.6

package/src/invite.ts

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

package/src/main.ts

@@ -69,7 +69,7 @@ const HELP = `nixamp — it really whips the terminal's ass.
 
   nixamp [source]                play it in the terminal
   nixamp serve [source] [options]  play here, and hand out a browser remote
-  nixamp daemon start|stop|status  serve in the background, and let go of it
+  nixamp daemon start|restart|stop|status  serve in the background, and let go of it
   nixamp attach                  put the player back in front of the daemon
   nixamp admin [--url U] [--key K] who is connected, and re-stream to them
   nixamp login [--with github]  sign in to nixamp.com, in a browser or here
@@ -188,9 +188,13 @@ Signing out does not touch it: that is what it is for.
   daemon: `nixamp daemon — a nixamp that outlives the terminal that started it.
 
   nixamp daemon start [source] [serve options]   start it, detached
+  nixamp daemon restart [source] [serve options] stop it and start it again
   nixamp daemon status                           where it is, and how long
   nixamp daemon stop                             stop it
 
+Restart with no arguments replays the ones it was started with, certificate
+and public URL included, so picking up a new version costs one command.
+
 It is \`nixamp serve\` with nobody holding its terminal, so it keeps playing and
 keeps serving its browser remote. One per user.
 
@@ -257,6 +261,17 @@ async function runDaemon(argv: string[]): Promise<number> {
     return 0;
   }
 
+  if (action === "restart") {
+    try {
+      const state = await d.restart(rest, entry);
+      for (const line of d.daemonLines(state)) console.log(line);
+      return 0;
+    } catch (error) {
+      console.error((error as Error).message);
+      return 1;
+    }
+  }
+
   if (action === "status") {
     const { running, state } = d.status();
     if (!state) {
@@ -283,7 +298,7 @@ async function runDaemon(argv: string[]): Promise<number> {
     return attach(rest);
   }
 
-  console.error(`nixamp daemon: unknown action ${action}. Try start, stop, status or attach.`);
+  console.error(`nixamp daemon: unknown action ${action}. Try start, restart, stop, status or attach.`);
   return 64;
 }
 

package/src/partyline.ts

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

package/src/protocol.ts

@@ -21,6 +21,14 @@ export interface RemoteTrack {
    * a browser could show played its soundtrack over a blank panel.
    */
   video?: boolean;
+  /**
+   * The source this track came in with, when it was not part of the library.
+   *
+   * Absent means it belongs to whatever this server was started on. Present
+   * means somebody added a folder or an album afterwards, and the name is what
+   * a client puts at the top of that block so the two are not one soup.
+   */
+  group?: string;
 }
 
 /** Everything a remote needs to draw the player. */

package/src/server.ts

@@ -59,7 +59,7 @@ import {
   type PaywallConfig,
   paywallFromEnv,
 } from "./paywall.ts";
-import { isRemote, playsInBrowser } from "./sources.ts";
+import { isRemote, playsInBrowser, sourceLabel } from "./sources.ts";
 import { codecsOf, videoArgs } from "./audio.ts";
 import {
   allowedForListening,
@@ -389,6 +389,28 @@ export function safeJoin(rootDir: string, urlPath: string): string | null {
   return full;
 }
 
+/**
+ * A track and the source it arrived with.
+ *
+ * The library a server was started on has no group: it is simply what this
+ * machine has. Anything added afterwards carries the name of the folder or
+ * album it came from, which is what lets a client draw the two apart instead
+ * of running them together.
+ */
+export type Loaded = Track & {
+  group?: string;
+  /**
+   * Whether this has a picture, when the name could not say.
+   *
+   * A file on disk is named `film.mkv` and that is answer enough. A live
+   * stream is `http://host/tipoffsport/KEY/301`, which says nothing at all --
+   * so it was treated as audio, transcoded with `-vn`, and arrived as a
+   * football match somebody could only listen to. Asked of ffprobe once, when
+   * the source is added, rather than guessed from a URL that has no opinion.
+   */
+  picture?: boolean;
+};
+
 /** What the HTTP layer needs from a player. Tests hand it a fake. */
 export interface Engine {
   /** `withTracks` false leaves the library out, for a frame that is only motion. */
@@ -398,11 +420,29 @@ export interface Engine {
   /** Absolute path of a track, or undefined when the index is not one. */
   trackPath(index: number): string | undefined;
   /**
-   * Play something else instead. Re-streaming is the whole reason the admin
-   * view exists: point a running server at a URL without restarting it and
-   * dropping every listener.
+   * Play something else instead of everything here.
+   *
+   * The big hammer, and no longer what adding a folder does: this is "point
+   * this server somewhere else", which throws the library away on purpose.
    */
   replace(tracks: Track[], root: string): void;
+  /**
+   * Play something as well as everything here.
+   *
+   * What somebody means by putting a folder in a box: the album shows up at
+   * the bottom of the playlist under its own name, and the music that was
+   * already there is still there. Answers how many tracks were new.
+   */
+  add(tracks: Track[], from: string): number;
+  /**
+   * Take an added source back out again, by the name `add` gave it.
+   *
+   * Nothing that came with the library can be dropped this way; the library is
+   * what the server is, and there is a command line for changing that.
+   */
+  drop(group: string): number;
+  /** Every added source, in the order they were added. */
+  groups(): string[];
   /**
    * The same tracks, now with their tags.
    *
@@ -416,7 +456,7 @@ export interface Engine {
   stop(): void;
 }
 
-export function toRemoteTracks(tracks: Track[]): RemoteTrack[] {
+export function toRemoteTracks(tracks: Loaded[]): RemoteTrack[] {
   return tracks.map((t) => ({
     title: t.title,
     artist: t.artist,
@@ -425,7 +465,11 @@ export function toRemoteTracks(tracks: Track[]): RemoteTrack[] {
     // Said out loud, because a remote cannot see the path and had been sending
     // every track to the audio element -- a film's soundtrack over a blank
     // panel, which is exactly what it looked like.
-    ...(hasPicture(t.path) ? { video: true } : {}),
+    // The name when it says something, what ffprobe found when it does not.
+    ...(t.picture ?? hasPicture(t.path) ? { video: true } : {}),
+    // Only for what was added; the library's own tracks say nothing, which is
+    // how a client knows they are the library.
+    ...(t.group ? { group: t.group } : {}),
   }));
 }
 
@@ -437,6 +481,23 @@ export function hasPicture(path: string): boolean {
   return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
 }
 
+/**
+ * Whether the name of a source tells us anything about what is inside it.
+ *
+ * A remote address with no extension -- an IPTV channel, a stream key, a
+ * redirect -- is the case where it does not, and the only way to find out is
+ * to look.
+ */
+export function nameSaysNothing(path: string): boolean {
+  if (!isRemote(path)) return false;
+  try {
+    const last = new URL(path).pathname.split("/").pop() ?? "";
+    return !last.includes(".");
+  } catch {
+    return false;
+  }
+}
+
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -463,7 +524,7 @@ export class PlayerEngine implements Engine {
   };
 
   constructor(
-    private tracks: Track[],
+    private tracks: Loaded[],
     private root: string,
     tools: Tools,
     /** Frames a second pushed to remotes. */
@@ -637,13 +698,85 @@ export class PlayerEngine implements Engine {
     this.push(true);
   }
 
+  /**
+   * Load something as well as what is already here.
+   *
+   * Adding a folder used to be `replace`, so pointing a server at an album on
+   * the web threw away the music on its disk: the playlist you were looking at
+   * turned into somebody else's twenty-eight tracks, and clicking your own
+   * files played theirs. Nothing about playback changes here -- whatever was
+   * playing keeps playing, at the same index, because the new tracks go on the
+   * end.
+   *
+   * Paths already loaded are skipped, so adding the same album twice is not
+   * two copies of it.
+   */
+  add(tracks: Track[], from: string): number {
+    const group = sourceLabel(from);
+    const known = new Set(this.tracks.map((track) => track.path));
+    const fresh = tracks.filter((track) => !known.has(track.path)).map((track) => ({ ...track, group }));
+    if (fresh.length === 0) return 0;
+    this.tracks = [...this.tracks, ...fresh];
+    // The list itself changed, so it has to ride this frame; a count nobody
+    // can index into is worse than no news at all.
+    this.push(true);
+    return fresh.length;
+  }
+
+  /**
+   * Take an added source back out.
+   *
+   * The track that is playing is followed rather than an index: removing an
+   * album from above the current track would otherwise slide the playlist out
+   * from under a listener mid-song. If the playing track is itself in what is
+   * being removed, playback stops -- there is nothing to keep playing.
+   */
+  drop(group: string): number {
+    if (group === "") return 0;
+    const playingPath = this.tracks[this.state.index]?.path;
+    const kept = this.tracks.filter((track) => track.group !== group);
+    const removed = this.tracks.length - kept.length;
+    if (removed === 0) return 0;
+    this.tracks = kept;
+    const stillThere = kept.findIndex((track) => track.path === playingPath);
+    if (stillThere === -1) {
+      this.halt();
+      this.state.index = this.clamp(this.state.index);
+    } else {
+      this.state.index = stillThere;
+    }
+    this.push(true);
+    return removed;
+  }
+
+  groups(): string[] {
+    const seen: string[] = [];
+    for (const track of this.tracks) {
+      if (track.group && !seen.includes(track.group)) seen.push(track.group);
+    }
+    return seen;
+  }
+
   retag(tracks: Track[], root: string): void {
-    // Dropped rather than applied if the library moved underneath: somebody
-    // re-streamed while the tagging was still running, and these tags describe
-    // something nobody is playing any more.
-    if (root !== this.root || tracks.length !== this.tracks.length) return;
-    if (tracks.some((track, at) => track.path !== this.tracks[at]?.path)) return;
-    this.tracks = tracks;
+    // Matched by path rather than by position, because the list is no longer
+    // required to be the one that was sent for tagging: somebody can add an
+    // album while a library's tags are still being read, and an exact-shape
+    // check would throw away every tag for it. Tags that describe tracks which
+    // are no longer here simply match nothing, which is the same protection
+    // the shape check was giving.
+    void root;
+    const byPath = new Map(tracks.map((track) => [track.path, track]));
+    let changed = false;
+    const merged = this.tracks.map((track) => {
+      const tagged = byPath.get(track.path);
+      if (!tagged || tagged === track) return track;
+      changed = true;
+      // The group is ours, not the tagger's: it knows what a track is called,
+      // not which pile it is in.
+      return { ...tagged, ...(track.group ? { group: track.group } : {}) };
+    });
+    if (!changed) return;
+    this.tracks = merged;
     // No stop, no index reset: the only thing that changes is what the titles
     // say, and every remote finds out because a snapshot goes out -- carrying
     // the list, since the titles are the whole point of this one.
@@ -667,6 +800,15 @@ export class EmptyEngine implements Engine {
     return undefined;
   }
   replace(): void {}
+  add(): number {
+    return 0;
+  }
+  drop(): number {
+    return 0;
+  }
+  groups(): string[] {
+    return [];
+  }
   retag(): void {}
   stop(): void {}
 }
@@ -681,6 +823,15 @@ const CORS: Record<string, string> = {
   "access-control-max-age": "86400",
 };
 
+/**
+ * How many nameless addresses are worth an ffprobe when a source is added.
+ *
+ * One is the ordinary case -- somebody pasting a channel -- and a directory
+ * listing of thousands must not turn into thousands of probes for an answer
+ * that only changes which element a browser uses.
+ */
+const PROBE_BY_HAND = 8;
+
 /** /api/v1/<provider>/oauth/start and .../callback, the house callback shape. */
 const OAUTH_ROUTE = /^\/api\/v1\/([a-z0-9-]+)\/oauth\/(start|callback)$/;
 
@@ -1098,7 +1249,17 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       path !== "/api/directory" &&
       !isSignInPath(path)
     ) {
-      const scope = scopeOf(keyFrom(request, url), key, listenKey);
+      let scope = scopeOf(keyFrom(request, url), key, listenKey);
+      // A key is how somebody who was invited proves it. It is not the only way
+      // to be allowed in: the person who owns this server is allowed in whether
+      // or not they still have the link, and their nixamp.com session says who
+      // they are. Without this, signing in as yourself and opening your own
+      // server was refused, and the address of a machine you administer was
+      // useless without a link you had to go and find.
+      if (scope === null && options.owner) {
+        const check = await options.owner.check(false, tokenFrom(request.headers));
+        if (check.allowed) scope = "control";
+      }
       if (scope === null) {
         // Counted, not because a 128-bit key falls to guessing, but because
         // somebody hammering one should stop costing this server anything.
@@ -1109,7 +1270,9 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           response.end(JSON.stringify({ error: "too many attempts; wait a moment" }));
           return;
         }
-        json(response, 401, { error: "this nixamp needs the key from its share link" });
+        json(response, 401, {
+          error: "this nixamp needs the key from its share link, or sign in as its owner",
+        });
         return;
       }
       if (scope === "listen" && !allowedForListening(path)) {
@@ -2030,16 +2193,50 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
-    // Re-stream: hand the running server a different source. The listeners
-    // stay connected; what they are listening to changes under them.
+    // Take an added source back out of the playlist. The library it was added
+    // to is untouched -- there is no group name that names it.
+    if (path === "/api/source/remove") {
+      if (request.method !== "POST") {
+        json(response, 405, { error: "POST only" });
+        return;
+      }
+      let group = "";
+      try {
+        group = String((JSON.parse(await readBody(request)) as { group?: unknown }).group ?? "");
+      } catch {
+        json(response, 400, { error: "bad JSON" });
+        return;
+      }
+      if (!group) {
+        json(response, 400, { error: "no group given" });
+        return;
+      }
+      const removed = engine.drop(group);
+      if (removed === 0) {
+        json(response, 404, { error: `nothing here came from ${group}` });
+        return;
+      }
+      json(response, 200, { ...engine.snapshot(), removed, groups: engine.groups() });
+      return;
+    }
+
+    // Hand the running server another source. The listeners stay connected;
+    // by default they get more to listen to, and only an explicit `replace`
+    // swaps what this server is for something else.
     if (path === "/api/source") {
       if (request.method !== "POST") {
         json(response, 405, { error: "POST only" });
         return;
       }
       let source = "";
+      let replacing = false;
       try {
-        source = String((JSON.parse(await readBody(request)) as { source?: unknown }).source ?? "");
+        const body = JSON.parse(await readBody(request)) as { source?: unknown; replace?: unknown };
+        source = String(body.source ?? "");
+        // Adding is what somebody means by putting a folder in a box, so it is
+        // the default. Replacing is the much larger claim that this server now
+        // serves that instead, so it is the one you have to ask for.
+        replacing = body.replace === true;
       } catch {
         json(response, 400, { error: "bad JSON" });
         return;
@@ -2049,13 +2246,42 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         return;
       }
       try {
-        const tracks = await options.load(source);
+        let tracks: Loaded[] = await options.load(source);
         if (tracks.length === 0) {
           json(response, 422, { error: `nothing to play at ${source}` });
           return;
         }
-        engine.replace(tracks, source);
-        // Names now, tags later, here as much as at startup: re-streaming a
+        // A handful of addresses whose names say nothing get asked what they
+        // are, so a live channel arrives as a picture rather than as its own
+        // soundtrack. Capped, because a playlist of five thousand of them is
+        // five thousand ffprobes and the answer only matters for the few a
+        // person adds by hand.
+        const looked = await Promise.all(
+          tracks.map(async (track, at) => {
+            if (at >= PROBE_BY_HAND || !nameSaysNothing(track.path)) return track;
+            const codecs = await codecsOf(
+              { ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null },
+              track.path,
+            );
+            return codecs.video === "" ? track : { ...track, picture: true };
+          }),
+        );
+        tracks = looked;
+
+        let added = tracks.length;
+        if (replacing) {
+          engine.replace(tracks, source);
+        } else {
+          added = engine.add(tracks, source);
+          if (added === 0) {
+            // Everything there was already here. Not an error -- the playlist
+            // is exactly what the caller asked for -- but worth saying, so a
+            // client can tell that apart from having added an album.
+            json(response, 200, { ...engine.snapshot(), added: 0, groups: engine.groups() });
+            return;
+          }
+        }
+        // Names now, tags later, here as much as at startup: loading a
         // directory of five thousand files used to read every tag before it
         // answered, with the event loop held the whole time.
         if (options.tag) {
@@ -2064,7 +2290,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
             .then((tagged) => engine.retag(tagged, source))
             .catch(() => {});
         }
-        json(response, 200, engine.snapshot());
+        json(response, 200, { ...engine.snapshot(), added, replaced: replacing, groups: engine.groups() });
       } catch (error) {
         json(response, 422, { error: (error as Error).message.replace(/^nixamp: /, "") });
       }
@@ -2095,15 +2321,21 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
 
       if (playsInBrowser(file) && capKbps === 0) {
         sendFile(request, response, file);
-      } else if (hasPicture(file)) {
-        // A film. It used to arrive as MP3 with `-vn`, which is to say as a
-        // soundtrack over a blank panel; what ffprobe finds inside decides how
-        // little work it takes to keep the picture.
+        return;
+      }
+      // A film, or something whose name refuses to say. A live channel at
+      // .../301 used to fall through to the audio branch and arrive as MP3
+      // with `-vn` -- a match you could only listen to.
+      if (hasPicture(file) || nameSaysNothing(file)) {
+        // What ffprobe finds inside decides how little work it takes to keep
+        // the picture, and whether there is a picture to keep at all.
         const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, file);
-        pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
-      } else {
-        transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
+        if (codecs.video !== "") {
+          pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
+          return;
+        }
       }
+      transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
       return;
     }
 

package/src/share.ts

@@ -199,7 +199,11 @@ export function scopeOf(offered: string | null, control: string | null, listen:
 
 /** Paths a listen key may have. Everything else needs the control key. */
 export function allowedForListening(path: string): boolean {
-  if (path === "/api/command" || path === "/api/source") return false;
+  if (path === "/api/command") return false;
+  // Prefix, not equality: everything under this changes what the server plays,
+  // and an exact check let a listen key reach /api/source/remove and delete an
+  // album out of somebody else's playlist.
+  if (path === "/api/source" || path.startsWith("/api/source/")) return false;
   return true;
 }
 

package/src/sources.ts

@@ -106,6 +106,27 @@ export function parsePls(text: string, base: string): Entry[] {
 }
 
 /** The last useful part of a path or URL, for when nothing named the track. */
+/**
+ * What to call a whole source, as a heading over the tracks it brought.
+ *
+ * `nameOf` answers for a file; this answers for the thing a person added --
+ * usually the last segment either way, but a URL that is only a host has no
+ * segment to take, and "the album at that address" reads better as the host
+ * than as the whole URL repeated over every row.
+ */
+export function sourceLabel(source: string): string {
+  const trimmed = source.replace(/\/+$/, "");
+  if (trimmed === "") return source;
+  const named = nameOf(trimmed);
+  if (named !== trimmed && named !== "") return named;
+  if (!isRemote(trimmed)) return trimmed;
+  try {
+    return new URL(trimmed).host;
+  } catch {
+    return trimmed;
+  }
+}
+
 export function nameOf(source: string): string {
   const remote = isRemote(source);
   const path = remote ? new URL(source).pathname : source;

package/web/dist/assets/{hls-3VKVEQE3-BirljKil.js → hls-3VKVEQE3-CKpUWwhK.js}

@@ -1 +1 @@
-import{t as e}from"./index-U2odRmpd.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-Bs7oVbTk.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};