nixamp 0.7.40 → 0.8.0

package/dist/catalogs.d.ts

@@ -0,0 +1,100 @@
+export interface CatalogEntry {
+    /** Stable across refreshes: a hash of the source, so a link to it survives. */
+    id: string;
+    title: string;
+    group: string;
+    logo: string;
+    /** Where the bytes are. Never shown to a listener. */
+    source: string;
+    live: boolean;
+    /** Seconds, when the list said; 0 for live and for "did not say". */
+    duration: number;
+}
+export interface CatalogInfo {
+    id: string;
+    name: string;
+    /** Where the list is read from. Shown to administrators only. */
+    source: string;
+    addedAt: number;
+    refreshedAt: number;
+    entries: number;
+    live: number;
+    vod: number;
+    groups: number;
+    /** What went wrong the last time it was read, or "". */
+    error: string;
+}
+/** A list bigger than this is not a playlist, it is a mistake. */
+export declare const MAX_LIST_BYTES: number;
+/** How long to wait for a provider before giving up on the list. */
+export declare const FETCH_TIMEOUT_MS = 30000;
+/**
+ * Live, or on demand?
+ *
+ * The list rarely says outright. A stated length is a film; a file extension
+ * is a file; an Xtream-shaped URL says /movie/ or /series/ for on demand and
+ * /live/ for a channel; and a bare stream key, an .m3u8 or an .ts is a channel.
+ */
+export declare function isLiveEntry(source: string, duration: number): boolean;
+export declare function entryId(source: string): string;
+/**
+ * Parse an extended m3u: `#EXTINF:-1 tvg-name="CNN" group-title="News",CNN HD`
+ * decorates the URL on the next line, and `#EXTGRP:News` names the group for
+ * lists that write it that way instead.
+ */
+export declare function parseCatalog(text: string, base: string): CatalogEntry[];
+export interface Group {
+    name: string;
+    count: number;
+    live: number;
+    vod: number;
+}
+/** Read a list, from disk or over the network, within reason. */
+export declare function readCatalog(source: string, send?: typeof fetch): Promise<string>;
+/**
+ * The catalogs on one server, and their entries.
+ *
+ * The index is small and written whenever it changes; each catalog's entries
+ * are kept in their own file so a restart does not have to ask every provider
+ * again before anybody can browse.
+ */
+export declare class Catalogs {
+    private readonly dir;
+    private readonly port;
+    private readonly send;
+    private readonly stored;
+    private readonly entries;
+    constructor(dir: string, port: number, send?: typeof fetch);
+    /** What was here last time, without asking any provider yet. */
+    load(): void;
+    /** Read every catalog that has no entries on disk. For boot. */
+    warm(): Promise<void>;
+    private cachePath;
+    private save;
+    private info;
+    list(): CatalogInfo[];
+    get(id: string): CatalogInfo | null;
+    /** Add a list and read it. The name is what a person called it, or the list's own filename. */
+    add(source: string, name: string): Promise<CatalogInfo>;
+    /** Read the list again. The old entries stay if the provider is down. */
+    refresh(id: string): Promise<CatalogInfo | null>;
+    remove(id: string): boolean;
+    groups(id: string): Group[] | null;
+    /** A page of entries: in one group, or all of them, matching a search. */
+    entries_(id: string, query: {
+        group?: string;
+        q?: string;
+        offset?: number;
+        limit?: number;
+    }): {
+        total: number;
+        entries: CatalogEntry[];
+    } | null;
+    entry(id: string, entryId_: string): CatalogEntry | null;
+}
+/** What a listener is shown of an entry: everything but where the bytes are. */
+export declare function shownEntry(entry: CatalogEntry): Omit<CatalogEntry, "source">;
+/** What a listener is shown of a catalog: everything but where the list is. */
+export declare function shownCatalog(info: CatalogInfo, admin: boolean): Omit<CatalogInfo, "source"> & {
+    source?: string;
+};

package/dist/channels.d.ts

@@ -40,6 +40,8 @@ export declare const GIVE_UP = 5;
  * channel that is quiet for half a minute is not being quiet, it is dead.
  */
 export declare const STALL = 30000;
+/** How long an on-demand channel stays up with nobody watching. */
+export declare const IDLE = 60000;
 /**
  * How much of the recent stream a newcomer is handed. About six seconds of
  * 720p television, and a couple of seconds of 192k MP3: enough to play
@@ -53,6 +55,8 @@ export interface ChannelOptions {
     ffmpeg: string[];
     onStart?: (info: ChannelInfo) => void;
     onEnd?: (info: ChannelInfo) => void;
+    /** How long an on-demand channel outlives its last viewer. Tests shorten it. */
+    idleMs?: number;
 }
 /**
  * One live source, and its audience.
@@ -90,6 +94,13 @@ export declare class Channel {
      */
     private recent;
     private recentBytes;
+    /**
+     * Started for whoever asked and stopped when nobody is left. A catalog
+     * channel is one of thousands; keeping every one that was ever clicked
+     * running would be a decoder per click, for ever.
+     */
+    ephemeral: boolean;
+    private idle;
     constructor(info: ChannelInfo, options: ChannelOptions, onGone: (id: string) => void);
     start(format: string): void;
     /**
@@ -162,6 +173,8 @@ export declare class Channel {
     /** Write to everyone, and drop anybody whose socket has gone. */
     private send;
     listen(listener: Listener): () => void;
+    /** Nobody is watching an on-demand channel: give it a minute, then stop. */
+    private idleOut;
     close(): void;
 }
 /**
@@ -203,6 +216,10 @@ export declare class Channels {
     restart(id: string): boolean;
     /** Whether a channel is one we fetch ourselves, and so can start over. */
     pulled(id: string): boolean;
+    /** Mark a channel as on demand: it stops itself a minute after its last viewer leaves. */
+    ephemeral(id: string): void;
+    /** How many on-demand channels are up, for a ceiling on decoders. */
+    get ephemeralCount(): number;
     /** What a listener should be told this channel is. */
     contentType(id: string): string;
     /** Attach a listener, or null when nothing is playing on that channel. */

package/dist/channels.js

@@ -31,6 +31,8 @@ export const GIVE_UP = 5;
  * channel that is quiet for half a minute is not being quiet, it is dead.
  */
 export const STALL = 30_000;
+/** How long an on-demand channel stays up with nobody watching. */
+export const IDLE = 60_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
 /**
@@ -111,6 +113,13 @@ export class Channel {
      */
     recent = [];
     recentBytes = 0;
+    /**
+     * Started for whoever asked and stopped when nobody is left. A catalog
+     * channel is one of thousands; keeping every one that was ever clicked
+     * running would be a decoder per click, for ever.
+     */
+    ephemeral = false;
+    idle = null;
     constructor(info, options, onGone) {
         this.info = info;
         this.options = options;
@@ -418,11 +427,27 @@ export class Channel {
         }
         this.listeners.add(listener);
         this.info.listeners = this.listeners.size;
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = null;
         return () => {
             this.listeners.delete(listener);
             this.info.listeners = this.listeners.size;
+            if (this.ephemeral && this.listeners.size === 0)
+                this.idleOut();
         };
     }
+    /** Nobody is watching an on-demand channel: give it a minute, then stop. */
+    idleOut() {
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = setTimeout(() => {
+            this.idle = null;
+            if (this.ephemeral && this.listeners.size === 0)
+                this.close();
+        }, this.options.idleMs ?? IDLE);
+        this.idle.unref?.();
+    }
     close() {
         if (this.closing)
             return;
@@ -434,6 +459,9 @@ export class Channel {
         if (this.watchdog)
             clearTimeout(this.watchdog);
         this.watchdog = null;
+        if (this.idle)
+            clearTimeout(this.idle);
+        this.idle = null;
         const said = lastLine(this.stderr);
         if (said && !this.info.error)
             this.info.error = said;
@@ -551,6 +579,23 @@ export class Channels {
     pulled(id) {
         return this.open.get(id)?.info.via === "pull";
     }
+    /** Mark a channel as on demand: it stops itself a minute after its last viewer leaves. */
+    ephemeral(id) {
+        const channel = this.open.get(id);
+        if (!channel)
+            return;
+        channel.ephemeral = true;
+        if (channel.listeners.size === 0)
+            channel.listen({ write: () => true, end: () => undefined })();
+    }
+    /** How many on-demand channels are up, for a ceiling on decoders. */
+    get ephemeralCount() {
+        let total = 0;
+        for (const channel of this.open.values())
+            if (channel.ephemeral)
+                total += 1;
+        return total;
+    }
     /** What a listener should be told this channel is. */
     contentType(id) {
         return this.open.get(id)?.info.kind === "video" ? "video/mp4" : "audio/mpeg";

package/dist/owner.js

@@ -102,5 +102,9 @@ export function needsAdmin(path, method = "GET") {
     // Listening to a channel is not: that is what the share link is for.
     if (path.startsWith("/api/channels/") && method !== "GET")
         return true;
+    // Adding, refreshing or removing a catalog is administering; browsing one,
+    // and picking something in it to play, is what the link is for.
+    if (path.startsWith("/api/catalogs") && method !== "GET" && !path.endsWith("/play"))
+        return true;
     return false;
 }

package/dist/server.d.ts

@@ -13,6 +13,7 @@ import { Directory } from "./directory.ts";
 import { PartyLine } from "./partyline.ts";
 import { Follows } from "./follows.ts";
 import { Favorites } from "./favorites.ts";
+import { Catalogs } from "./catalogs.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
 export declare const SERVE_BAND_COUNT = 24;
@@ -337,6 +338,12 @@ export declare class PlayerEngine implements Engine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * How many channels a server will start on demand at once. Each is an ffmpeg,
+ * and a catalog has thousands of entries; this is what keeps a room full of
+ * curious people from becoming a room full of decoders.
+ */
+export declare const MAX_ON_DEMAND = 4;
 /**
  * Probe a source and start carrying it as a channel of its own.
  *
@@ -414,6 +421,8 @@ export interface HandlerOptions {
     channels?: Channels;
     /** Write down the channels this server pulls, so a restart puts them back. */
     rememberChannels?: (list: RememberedChannel[]) => void;
+    /** The m3u catalogs this server keeps, browsable by group. */
+    catalogs?: Catalogs;
     /** Live audio going out to RTMP. */
     broadcaster?: Broadcaster;
     /** Where a broadcast should send, and what it should look like. */

package/dist/server.js

@@ -38,6 +38,7 @@ import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.js";
 import pg from "pg";
 import { Follows, phoneFrom } from "./follows.js";
 import { Favorites, favoriteUrl } from "./favorites.js";
+import { Catalogs, shownCatalog, shownEntry } from "./catalogs.js";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
@@ -708,6 +709,12 @@ export class PlayerEngine {
  * looking at what is on wants "that album from the web", not every track in
  * it. An entry names where to start, so clicking it plays.
  */
+/**
+ * How many channels a server will start on demand at once. Each is an ffmpeg,
+ * and a catalog has thousands of entries; this is what keeps a room full of
+ * curious people from becoming a room full of decoders.
+ */
+export const MAX_ON_DEMAND = 4;
 /**
  * Probe a source and start carrying it as a channel of its own.
  *
@@ -1876,6 +1883,134 @@ export function createHandler(engine, options) {
         }
         // --- several streams at once ------------------------------------------
         //
+        // --- catalogs: m3u lists you can browse ---------------------------------
+        //
+        // An IPTV list is thousands of entries with groups and logos. Kept as a
+        // catalog it stays browsable; poured into the playlist it was three
+        // thousand flat rows. Anyone with the link browses and plays; adding,
+        // refreshing and removing is administering (see needsAdmin).
+        if ((path === "/api/catalogs" || path.startsWith("/api/catalogs/")) && options.catalogs) {
+            const catalogs = options.catalogs;
+            if (path === "/api/catalogs" && request.method === "GET") {
+                // Where a list is read from is the administrator's business, not a
+                // listener's: it can carry a provider's credentials in the URL.
+                const holdsControl = key === null || scopeOf(keyFrom(request, url), key, null) === "control";
+                const admin = options.owner
+                    ? (await options.owner.check(holdsControl, tokenFrom(request.headers))).allowed
+                    : holdsControl;
+                json(response, 200, { catalogs: catalogs.list().map((one) => shownCatalog(one, admin)) });
+                return;
+            }
+            if (path === "/api/catalogs" && request.method === "POST") {
+                let body = {};
+                try {
+                    body = JSON.parse(await readBody(request));
+                }
+                catch {
+                    json(response, 400, { error: "bad JSON" });
+                    return;
+                }
+                try {
+                    const added = await catalogs.add(String(body.source ?? ""), String(body.name ?? ""));
+                    json(response, added.error ? 422 : 200, {
+                        ok: !added.error,
+                        catalog: shownCatalog(added, true),
+                        ...(added.error ? { error: added.error } : {}),
+                    });
+                }
+                catch (error) {
+                    json(response, 422, { error: error.message.replace(/^nixamp: /, "") });
+                }
+                return;
+            }
+            const [rawId = "", action = "", entryId = "", sub = ""] = path.slice("/api/catalogs/".length).split("/");
+            const id = decodeURIComponent(rawId);
+            if (!catalogs.get(id)) {
+                json(response, 404, { error: "no such catalog" });
+                return;
+            }
+            if (action === "" && request.method === "DELETE") {
+                json(response, 200, { ok: catalogs.remove(id) });
+                return;
+            }
+            if (action === "refresh" && request.method === "POST") {
+                const refreshed = await catalogs.refresh(id);
+                json(response, refreshed && !refreshed.error ? 200 : 422, {
+                    ok: refreshed !== null && !refreshed.error,
+                    ...(refreshed ? { catalog: shownCatalog(refreshed, true) } : {}),
+                    ...(refreshed?.error ? { error: refreshed.error } : {}),
+                });
+                return;
+            }
+            if (action === "groups" && request.method === "GET") {
+                json(response, 200, { groups: catalogs.groups(id) ?? [] });
+                return;
+            }
+            if (action === "entries" && entryId === "" && request.method === "GET") {
+                const page = catalogs.entries_(id, {
+                    group: url.searchParams.get("group") ?? "",
+                    q: url.searchParams.get("q") ?? "",
+                    offset: Number(url.searchParams.get("offset") ?? "0") || 0,
+                    limit: Number(url.searchParams.get("limit") ?? "200") || 200,
+                }) ?? { total: 0, entries: [] };
+                json(response, 200, { total: page.total, entries: page.entries.map(shownEntry) });
+                return;
+            }
+            const entry = action === "entries" && entryId !== "" ? catalogs.entry(id, decodeURIComponent(entryId)) : null;
+            if (!entry) {
+                json(response, 404, { error: "no such entry" });
+                return;
+            }
+            // Play. A live entry becomes a channel, started for whoever asked and
+            // stopped a minute after the last viewer leaves; a film is played on
+            // its own, straight from the source through ffmpeg.
+            if (sub === "play" && request.method === "POST") {
+                if (!entry.live) {
+                    json(response, 200, {
+                        kind: "vod",
+                        url: `/api/catalogs/${encodeURIComponent(id)}/entries/${encodeURIComponent(entry.id)}/stream`,
+                        name: entry.title,
+                    });
+                    return;
+                }
+                if (!options.channels) {
+                    json(response, 503, { error: "this server cannot carry channels" });
+                    return;
+                }
+                const channelId = cleanId(`cat-${entry.id}`);
+                if (!options.channels.has(channelId)) {
+                    if (options.channels.ephemeralCount >= MAX_ON_DEMAND) {
+                        json(response, 429, { error: `this server is already carrying ${MAX_ON_DEMAND} channels on demand; try again in a minute` });
+                        return;
+                    }
+                    const started = await pullChannel(options.channels, options.ffprobe ?? ["ffprobe"], channelId, entry.title, entry.source);
+                    if (!started) {
+                        json(response, 409, { error: "that channel is already starting" });
+                        return;
+                    }
+                    options.channels.ephemeral(channelId);
+                }
+                json(response, 200, { kind: "live", channel: channelId, name: entry.title });
+                return;
+            }
+            if (sub === "stream" && request.method === "GET") {
+                if (!options.media) {
+                    json(response, 403, { error: "media streaming is off" });
+                    return;
+                }
+                watch(request, response, "stream", entry.title);
+                const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, entry.source);
+                if (codecs.video !== "") {
+                    pipeFfmpeg(request, response, entry.source, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs), "video/mp4");
+                }
+                else {
+                    transcode(request, response, entry.source, options.ffmpeg ?? ["ffmpeg"]);
+                }
+                return;
+            }
+            json(response, 404, { error: "no such endpoint" });
+            return;
+        }
         // A channel is one publisher and everybody listening to them. Two or three
         // devices can publish at once, each to their own channel, and a listener
         // picks which to hear.
@@ -2906,6 +3041,11 @@ export async function serve(argv, version = "0.1.0") {
                 console.log(`  "${one.id}" is already on.`);
         });
     }
+    // The m3u catalogs kept here: read from disk now, and any that were never
+    // read are fetched in the background so browsing does not wait on a provider.
+    const catalogs = new Catalogs(stateDir(), options.port);
+    catalogs.load();
+    void catalogs.warm().catch(() => undefined);
     const destinations = parseDestinations(options.rtmp);
     const broadcaster = new Broadcaster(tools.ffmpeg);
     const ingest = options.ingest
@@ -3092,6 +3232,7 @@ export async function serve(argv, version = "0.1.0") {
         owner,
         channels,
         rememberChannels: remembering,
+        catalogs,
         publishUrls: () => publishUrls,
         serverName: options.name || hostname(),
         homeSource: root,

package/dist/session.js

@@ -357,20 +357,31 @@ export async function chooseWay(ways, options) {
     if (options.device)
         return ways.device ? "device" : null;
     // Naming an address is asking for the password flow by implication.
-    if (!ways.device || options.email || !process.stdin.isTTY)
-        return "password";
-    if (ways.providers.length === 0)
+    if (!ways.device || options.email)
         return "password";
+    // A site with no providers configured still has a browser to approve in,
+    // and that is the way in from a terminal: a code, a page, a click. This
+    // used to fall through to a password prompt the moment the provider list
+    // was empty, which is what nixamp.com answers, so nobody ever saw the
+    // browser flow that was built for exactly this. With no terminal to draw
+    // a menu on, the browser page offers the providers instead.
+    if (ways.providers.length === 0 || !process.stdin.isTTY)
+        return "device";
     console.log("How would you like to sign in?");
     ways.providers.forEach((provider, index) => console.log(`  ${index + 1}) ${provider.name}`));
-    console.log(`  ${ways.providers.length + 1}) Email and password`);
+    console.log(`  ${ways.providers.length + 1}) In a browser you are already signed in to`);
+    console.log(`  ${ways.providers.length + 2}) Email and password`);
     const typed = await ask(`Choose [1]: `);
     const picked = typed === "" ? 1 : Number(typed);
-    if (!Number.isInteger(picked) || picked < 1 || picked > ways.providers.length + 1) {
-        console.log("Not one of those, so: email and password.");
-        return "password";
+    if (!Number.isInteger(picked) || picked < 1 || picked > ways.providers.length + 2) {
+        console.log("Not one of those, so: in a browser.");
+        return "device";
     }
-    return picked === ways.providers.length + 1 ? "password" : (ways.providers[picked - 1]?.id ?? "password");
+    if (picked === ways.providers.length + 1)
+        return "device";
+    if (picked === ways.providers.length + 2)
+        return "password";
+    return ways.providers[picked - 1]?.id ?? "device";
 }
 const day = (at) => (at ? new Date(at).toISOString().slice(0, 10) : "never");
 /**

package/package.json

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

package/src/channels.ts

@@ -64,6 +64,8 @@ export const GIVE_UP = 5;
  * channel that is quiet for half a minute is not being quiet, it is dead.
  */
 export const STALL = 30_000;
+/** How long an on-demand channel stays up with nobody watching. */
+export const IDLE = 60_000;
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
 /**
@@ -116,6 +118,8 @@ export interface ChannelOptions {
   ffmpeg: string[];
   onStart?: (info: ChannelInfo) => void;
   onEnd?: (info: ChannelInfo) => void;
+  /** How long an on-demand channel outlives its last viewer. Tests shorten it. */
+  idleMs?: number;
 }
 
 /**
@@ -151,6 +155,13 @@ export class Channel {
    */
   private recent: Buffer[] = [];
   private recentBytes = 0;
+  /**
+   * Started for whoever asked and stopped when nobody is left. A catalog
+   * channel is one of thousands; keeping every one that was ever clicked
+   * running would be a decoder per click, for ever.
+   */
+  ephemeral = false;
+  private idle: ReturnType<typeof setTimeout> | null = null;
 
   constructor(
     readonly info: ChannelInfo,
@@ -466,12 +477,25 @@ export class Channel {
     }
     this.listeners.add(listener);
     this.info.listeners = this.listeners.size;
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = null;
     return () => {
       this.listeners.delete(listener);
       this.info.listeners = this.listeners.size;
+      if (this.ephemeral && this.listeners.size === 0) this.idleOut();
     };
   }
 
+  /** Nobody is watching an on-demand channel: give it a minute, then stop. */
+  private idleOut(): void {
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = setTimeout(() => {
+      this.idle = null;
+      if (this.ephemeral && this.listeners.size === 0) this.close();
+    }, this.options.idleMs ?? IDLE);
+    this.idle.unref?.();
+  }
+
   close(): void {
     if (this.closing) return;
     this.closing = true;
@@ -480,6 +504,8 @@ export class Channel {
     this.timer = null;
     if (this.watchdog) clearTimeout(this.watchdog);
     this.watchdog = null;
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = null;
     const said = lastLine(this.stderr);
     if (said && !this.info.error) this.info.error = said;
     const child = this.child;
@@ -615,6 +641,21 @@ export class Channels {
     return this.open.get(id)?.info.via === "pull";
   }
 
+  /** Mark a channel as on demand: it stops itself a minute after its last viewer leaves. */
+  ephemeral(id: string): void {
+    const channel = this.open.get(id);
+    if (!channel) return;
+    channel.ephemeral = true;
+    if (channel.listeners.size === 0) channel.listen({ write: () => true, end: () => undefined })();
+  }
+
+  /** How many on-demand channels are up, for a ceiling on decoders. */
+  get ephemeralCount(): number {
+    let total = 0;
+    for (const channel of this.open.values()) if (channel.ephemeral) total += 1;
+    return total;
+  }
+
   /** What a listener should be told this channel is. */
   contentType(id: string): string {
     return this.open.get(id)?.info.kind === "video" ? "video/mp4" : "audio/mpeg";

package/src/owner.ts

@@ -119,5 +119,8 @@ export function needsAdmin(path: string, method = "GET"): boolean {
   // Publishing to a channel, or ending one, is administering the server.
   // Listening to a channel is not: that is what the share link is for.
   if (path.startsWith("/api/channels/") && method !== "GET") return true;
+  // Adding, refreshing or removing a catalog is administering; browsing one,
+  // and picking something in it to play, is what the link is for.
+  if (path.startsWith("/api/catalogs") && method !== "GET" && !path.endsWith("/play")) return true;
   return false;
 }