nixamp 0.34.0 → 0.36.0

package/dist/auto-stations.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Auto stations: a station for every genre the library has, kept up to date.
+ *
+ * Radio from the music's own genre tags, folded into genres a listener would
+ * recognise ("Rap/Hip-Hop", "Hip Hop" and "Gangsta" are all Hip-Hop; "Pop,
+ * Rock, Metal" is in three). TV from the genres nichedb knows for each film.
+ * Lectures, interviews and talk are not music and stay out of radio.
+ *
+ * Each genre's station is found again by its key on the next sync and its
+ * files replaced, so new music lands in the right station by itself and a
+ * station's link never changes. Nothing is published: an auto station is
+ * unlisted, a link for whoever the owner hands it to. Making one public is
+ * the owner's decision, with the rights basis that asks for.
+ *
+ * TV costs a core per running station (it is re-encoded), so only the
+ * biggest few run; the rest are made and wait, stopped.
+ */
+import type { LibraryIndex } from "./library-index.ts";
+import type { StationRunner } from "./station-runner.ts";
+import type { StationStore } from "./stations.ts";
+/** The genres a tag belongs to, recognisably named; [] when it is not music or not known. */
+export declare function genreBuckets(raw: string): string[];
+export interface AutoOptions {
+    /** Radio from tags; TV from nichedb's genres. */
+    video: boolean;
+    /** A genre needs at least this many files (radio) to get a station. */
+    minItems: number;
+    /** Films for a TV station. */
+    minFilms: number;
+    start: boolean;
+    /** TV stations running at once. */
+    maxVideoRunning: number;
+    /** Seconds between breaks on the stations this makes. */
+    breaksEvery: number;
+}
+export declare const DEFAULT_AUTO: AutoOptions;
+export interface AutoReport {
+    radio: Array<{
+        genre: string;
+        id: string;
+        files: number;
+        made: boolean;
+        running: boolean;
+    }>;
+    tv: Array<{
+        genre: string;
+        id: string;
+        films: number;
+        made: boolean;
+        running: boolean;
+    }>;
+    skipped: string[];
+}
+export interface AutoDeps {
+    index: LibraryIndex;
+    store: StationStore;
+    runner: StationRunner;
+    owner: string;
+    /** nichedb's genres for a film, from the enrichment cache or a lookup; [] when unknown. */
+    filmGenres?: (title: string) => Promise<string[]>;
+    /** Whether another station may be started now (the server's running limit). */
+    mayStart: () => boolean;
+    log?: (line: string) => void;
+}
+/** Make or update a station per genre; start what the limits allow. */
+export declare function syncAutoStations(deps: AutoDeps, options?: AutoOptions): Promise<AutoReport>;

package/dist/auto-stations.js

@@ -0,0 +1,108 @@
+import { shown } from "./library-index.js";
+const RULES = [
+    [/metal|thrash|trash|doom|death|grind|neue deutsche|h(a|ä)rte|djent|metalcore/i, "Metal"],
+    [/punk|hardcore|emo|screamo/i, "Punk"],
+    [/hip.?hop|\brap\b|gangsta|trap|grime|drill/i, "Hip-Hop"],
+    [/industrial/i, "Industrial"],
+    [/electro|techno|house|edm|dance|trance|ambient|drum.?n.?bass|dubstep|synth/i, "Electronic"],
+    [/reggae|\bska\b|\bdub\b|dancehall/i, "Reggae"],
+    [/jazz|swing|bebop/i, "Jazz"],
+    [/blues/i, "Blues"],
+    [/classical|symphon|orchestr|baroque|opera/i, "Classical"],
+    [/country|folk|bluegrass|americana/i, "Country & Folk"],
+    [/soul|r&b|rnb|funk|motown|gospel/i, "Soul & R&B"],
+    [/latin|reggaeton|salsa|bachata|cumbia/i, "Latin"],
+    [/alternat|indie|ind(e|é)|grunge|shoegaze/i, "Alternative"],
+    [/rock/i, "Rock"],
+    [/pop/i, "Pop"],
+];
+const NOT_MUSIC = /lecture|interview|audiobook|podcast|speech|spoken|talk|course|sermon|lesson|comedy/i;
+/** The genres a tag belongs to, recognisably named; [] when it is not music or not known. */
+export function genreBuckets(raw) {
+    if (!raw || NOT_MUSIC.test(raw))
+        return [];
+    const out = new Set();
+    for (const part of raw.split(/[,;/|]+|\s+&\s+/)) {
+        const hit = RULES.find(([pattern]) => pattern.test(part));
+        if (hit)
+            out.add(hit[1]);
+    }
+    return [...out];
+}
+export const DEFAULT_AUTO = { video: true, minItems: 10, minFilms: 3, start: true, maxVideoRunning: 2, breaksEvery: 600 };
+function order(items) {
+    return [...items].sort((a, b) => {
+        const x = shown(a), y = shown(b);
+        return (x.albumArtist || x.artist).localeCompare(y.albumArtist || y.artist) || x.album.localeCompare(y.album) || x.disc - y.disc || x.track - y.track || a.rel.localeCompare(b.rel);
+    });
+}
+async function upsert(deps, key, name, paths, video, options) {
+    const existing = deps.store.byAuto(key);
+    if (existing) {
+        const same = existing.items.length === paths.length && existing.items.every((one, at) => one === paths[at]);
+        return { station: same ? existing : deps.store.update(existing.id, {}, paths), made: false };
+    }
+    const station = deps.store.create({ name, shuffle: true, repeat: true, video, breaksEvery: options.breaksEvery }, paths, deps.owner);
+    deps.store.markAuto(station.id, key);
+    // A link, not a listing: unlisted needs no rights basis and publishes nothing.
+    deps.store.setAccess(station.id, { visibility: "unlisted" }, deps.owner || "auto");
+    return { station, made: true };
+}
+/** Make or update a station per genre; start what the limits allow. */
+export async function syncAutoStations(deps, options = DEFAULT_AUTO) {
+    const report = { radio: [], tv: [], skipped: [] };
+    const ready = deps.index.search({ state: "ready", limit: 500, offset: 0 });
+    // search() pages at 500; walk them all.
+    const all = [...ready.items];
+    for (let offset = 500; offset < ready.total; offset += 500)
+        all.push(...deps.index.search({ state: "ready", limit: 500, offset }).items);
+    const radio = new Map();
+    for (const item of all) {
+        if (item.video)
+            continue;
+        for (const genre of genreBuckets(shown(item).genre)) {
+            const list = radio.get(genre) ?? [];
+            list.push(item);
+            radio.set(genre, list);
+        }
+    }
+    for (const [genre, items] of [...radio].sort((a, b) => b[1].length - a[1].length)) {
+        if (items.length < options.minItems) {
+            report.skipped.push(`${genre} radio (${items.length} files)`);
+            continue;
+        }
+        const { station, made } = await upsert(deps, `genre:audio:${genre.toLowerCase()}`, `${genre} Radio`, order(items).map((one) => one.path), false, options);
+        let running = station.desired === "running";
+        if (!running && options.start && deps.mayStart()) {
+            await deps.runner.start(station.id).then(() => { running = true; }, (error) => deps.log?.(`  auto stations: ${genre} Radio did not start: ${error.message}`));
+        }
+        report.radio.push({ genre, id: station.id, files: items.length, made, running });
+    }
+    if (options.video && deps.filmGenres) {
+        const tv = new Map();
+        for (const item of all) {
+            if (!item.video || item.duration < 40 * 60)
+                continue;
+            const genres = await deps.filmGenres(shown(item).title).catch(() => []);
+            for (const genre of genres.slice(0, 2)) {
+                const list = tv.get(genre) ?? [];
+                list.push(item);
+                tv.set(genre, list);
+            }
+        }
+        let runningTv = deps.store.list().filter((one) => one.video && one.auto && one.desired === "running").length;
+        for (const [genre, films] of [...tv].sort((a, b) => b[1].length - a[1].length)) {
+            if (films.length < options.minFilms) {
+                report.skipped.push(`${genre} TV (${films.length} films)`);
+                continue;
+            }
+            const { station, made } = await upsert(deps, `genre:video:${genre.toLowerCase()}`, `${genre} TV`, films.map((one) => one.path), true, options);
+            let running = station.desired === "running";
+            if (!running && options.start && runningTv < options.maxVideoRunning && deps.mayStart()) {
+                await deps.runner.start(station.id).then(() => { running = true; runningTv += 1; }, (error) => deps.log?.(`  auto stations: ${genre} TV did not start: ${error.message}`));
+            }
+            report.tv.push({ genre, id: station.id, films: films.length, made, running });
+        }
+    }
+    return report;
+}

package/dist/channels.d.ts

@@ -112,7 +112,7 @@ export interface PullResume {
      * 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">;
+    rotation?: Pick<PlaylistInput, "repeat" | "order" | "current" | "excluded" | "onFailure" | "passOver" | "breaks">;
 }
 /**
  * A source read by us rather than by ffmpeg: what to tell ffmpeg it is,

package/dist/library-index.d.ts

@@ -127,6 +127,8 @@ export declare class LibraryIndex {
     private timer;
     private dirty;
     private jobs;
+    /** Told when any scan finishes, for whatever keeps up with the library (auto stations). */
+    onScanned: ((report: ScanReport) => void) | null;
     constructor(file: string, io?: {
         read: (path: string) => string | null;
         write: (path: string, body: string) => void;

package/dist/library-index.js

@@ -243,6 +243,8 @@ export class LibraryIndex {
     timer = null;
     dirty = false;
     jobs = new Map();
+    /** Told when any scan finishes, for whatever keeps up with the library (auto stations). */
+    onScanned = null;
     constructor(file, io = {
         read: (path) => { try {
             return readFileSync(path, "utf8");
@@ -531,6 +533,12 @@ export class LibraryIndex {
         report.status = signal.aborted ? "cancelled" : "done";
         report.finishedAt = this.now();
         this.touch();
+        if (report.status === "done") {
+            try {
+                this.onScanned?.(report);
+            }
+            catch { /* a listener's trouble is not the scan's */ }
+        }
         return report;
     }
     /** The owner's corrections; an empty value clears that field's correction. */

package/dist/library.d.ts

@@ -3,6 +3,8 @@ export interface Config {
     library?: string;
     /** Whether this machine is listed in the public directory; unset until chosen. */
     publish?: boolean;
+    /** Auto stations: a station per genre, re-synced after every library scan. */
+    autoStations?: Record<string, unknown>;
 }
 export declare function configPath(): string;
 export declare function readConfig(): Config;

package/dist/library.js

@@ -31,6 +31,7 @@ export function readConfig() {
         return {
             ...(typeof record["library"] === "string" ? { library: record["library"] } : {}),
             ...(typeof record["publish"] === "boolean" ? { publish: record["publish"] } : {}),
+            ...(typeof record["autoStations"] === "object" && record["autoStations"] !== null ? { autoStations: record["autoStations"] } : {}),
         };
     }
     catch {

package/dist/playlist-input.d.ts

@@ -29,6 +29,15 @@ export interface PlaylistInput {
      * still arriving, and the channel redials and waits for it.
      */
     passOver?: boolean;
+    /**
+     * A break every so often, between entries and never in the middle of one:
+     * `next` answers a file to play (an advert, an ident) or null for no break
+     * this time. The break is outside the rotation and the station's history.
+     */
+    breaks?: {
+        everySeconds: number;
+        next: () => Promise<string | null>;
+    };
     /** Told when an entry is passed over because it would not play. */
     onFailure?: (event: {
         at: number;

package/dist/playlist-input.js

@@ -60,9 +60,10 @@ export class PlaylistInputStream {
             if (files.length === 0)
                 throw new Error("The playlist is empty");
             let order = orderFor(files);
-            let step = Math.min(o.at, order.length);
+            let step = Math.min(Math.max(0, o.at), order.length);
             let played = 0;
             let last = "";
+            let lastBreak = 0;
             for (;;) {
                 if (signal.aborted)
                     break;
@@ -93,11 +94,23 @@ export class PlaylistInputStream {
                     continue;
                 }
                 {
-                    const at = order[step];
-                    step += 1;
-                    const file = files[at];
-                    last = file;
-                    if (o.excluded?.(file))
+                    // A break, when one is due: in place of the next entry, which stays
+                    // next. Not at the very start, and never inside an entry.
+                    let breakFile = null;
+                    if (o.breaks && !first && offset - lastBreak >= o.breaks.everySeconds) {
+                        lastBreak = offset;
+                        breakFile = await o.breaks.next().catch(() => null);
+                        if (signal.aborted)
+                            return;
+                    }
+                    const isBreak = breakFile !== null;
+                    const at = isBreak ? -1 : order[step];
+                    if (!isBreak)
+                        step += 1;
+                    const file = isBreak ? breakFile : files[at];
+                    if (!isBreak)
+                        last = file;
+                    if (!isBreak && o.excluded?.(file))
                         continue;
                     const position = first && step - 1 === o.at ? o.position : 0;
                     first = false;
@@ -174,14 +187,23 @@ export class PlaylistInputStream {
                             abort();
                             await closed;
                         }
-                        failuresInARow = 0;
-                        played += 1;
+                        if (!isBreak) {
+                            failuresInARow = 0;
+                            played += 1;
+                        }
                         // Match the frame grid used above so rounding cannot accumulate a
                         // backwards timestamp over hundreds of short files.
                         const length = skipped ? Math.min(duration, reached) : duration;
                         offset += o.video ? Math.ceil(length * 30) / 30 : length;
+                        // The next break is counted from the end of this one, so a spot
+                        // longer than the gap cannot follow itself.
+                        if (isBreak)
+                            lastBreak = offset;
                     }
                     catch (error) {
+                        // A break that would not play is simply no break.
+                        if (isBreak && !signal.aborted)
+                            continue;
                         if (signal.aborted || !o.passOver)
                             throw error;
                         // Passed over, not dialled again: the next entry is what a

package/dist/server.d.ts

@@ -26,6 +26,7 @@ import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
 import { StationRunner } from "./station-runner.ts";
 import { StationStore } from "./stations.ts";
+import { StationUsage, type Limits } from "./station-metering.ts";
 import { CompressionService } from "./compression/service.ts";
 import { Enricher } from "./enrich.ts";
 import { Follows } from "./follows.ts";
@@ -582,6 +583,12 @@ export interface HandlerOptions {
     stations?: {
         store: StationStore;
         runner: StationRunner;
+        usage?: StationUsage;
+        limits?: Limits;
+        auto?: {
+            sync: (input: Record<string, unknown>) => Promise<unknown>;
+            setting: () => unknown;
+        };
     };
     web: string | null;
     /** Branded clients on this same backend, keyed by an explicitly configured host. */

package/dist/server.js

@@ -61,8 +61,12 @@ import { ListenerStore } from "./library-user.js";
 import { Importer } from "./handoff.js";
 import { handleHandoffs } from "./handoff-routes.js";
 import { STATION_PAGE, STATION_PAGE_CSP, STATION_PAGE_HTML } from "./station-page.js";
+import { GUIDE_CSP, GUIDE_HTML, guideHosts } from "./station-guide.js";
 import { StationRunner } from "./station-runner.js";
 import { StationError, StationStore, stationOfChannel } from "./stations.js";
+import { STATION_CONTROL_LIMIT, StationUsage, limitsFromEnv } from "./station-metering.js";
+import { StationBreaks } from "./station-breaks.js";
+import { DEFAULT_AUTO, syncAutoStations } from "./auto-stations.js";
 import { CompressionService } from "./compression/service.js";
 import { handleChannelCompression, handleCompressionApi, handleStaticRelay } from "./compression/routes.js";
 import { DEFAULT_SITE as NICHEDB, Enricher, FIXTURE_TTL_MS } from "./enrich.js";
@@ -2130,6 +2134,11 @@ export function createHandler(engine, options) {
         // port is open from another device before wondering whether the link is
         // wrong, and it says nothing about the library.
         const eventChannelRequest = Boolean(channelId && await eventForChannel());
+        // The public station guide: at /guide, and at the front of a host named
+        // for it (a Moshpit name such as live.streaming, NIXAMP_GUIDE_HOSTS).
+        const requestHost = String(request.headers["x-forwarded-host"] ?? request.headers.host ?? "").split(",")[0].trim().replace(/:\d+$/, "").toLowerCase();
+        const isGuidePage = Boolean(options.stations) && (request.method === "GET" || request.method === "HEAD") &&
+            (path === "/guide" || (path === "/" && guideHosts().has(requestHost)));
         // Whether this request holds only the listen key. A listener may browse
         // and hear the library, but where it lives on this machine is the
         // owner's business: the absolute path names the user account and the disk.
@@ -2141,6 +2150,7 @@ export function createHandler(engine, options) {
             // A station's link is its own key, checked by the station.
             !isStationListenPath(path) &&
             !STATION_PAGE.test(path) &&
+            !isGuidePage &&
             !eventChannelRequest) {
             let scope = scopeOf(keyFrom(request, url), key, listenKey);
             // Kept for the routes below that answer a listener with less.
@@ -2193,6 +2203,17 @@ export function createHandler(engine, options) {
             }
             return { allowed: false, account: "" };
         };
+        if (isGuidePage) {
+            response.writeHead(200, {
+                "content-type": "text/html; charset=utf-8",
+                "cache-control": "no-cache",
+                "content-security-policy": GUIDE_CSP,
+                "referrer-policy": "no-referrer",
+                "x-content-type-options": "nosniff",
+            });
+            response.end(request.method === "HEAD" ? undefined : GUIDE_HTML);
+            return;
+        }
         // The page a station's link opens. The same bytes for every station: it
         // reads its id and token from its own address.
         if (options.stations && STATION_PAGE.test(path) && (request.method === "GET" || request.method === "HEAD")) {
@@ -2274,6 +2295,13 @@ export function createHandler(engine, options) {
                 json,
                 readBody,
                 headers: CORS,
+                ...(options.stations.usage ? { usage: options.stations.usage } : {}),
+                ...(options.stations.limits ? { limits: options.stations.limits } : {}),
+                ...(options.stations.auto ? { auto: options.stations.auto } : {}),
+                throttle: () => {
+                    const verdict = guard.check(`stations:${control.account || callerOf(request.headers, request.socket.remoteAddress, behindProxy)}`, STATION_CONTROL_LIMIT);
+                    return verdict.ok ? null : { retryAfter: verdict.retryAfter };
+                },
             });
             return;
         }
@@ -6168,7 +6196,21 @@ export async function serve(argv, version = "0.1.0") {
     const listeners = new ListenerStore(ListenerStore.fileFor(stateDir(), options.port));
     const library = { index: libraryIndex, probe: probeFile, retag: retagPlayer, listeners };
     const stationStore = new StationStore(StationStore.fileFor(stateDir(), options.port));
+    // What stations deliver, per month, and the operator's limits on it.
+    const stationUsage = new StationUsage(StationUsage.fileFor(stateDir(), options.port));
+    const stationLimits = limitsFromEnv();
+    process.once("exit", () => stationUsage.flush());
+    // Breaks between songs and films: the network's spot, or a house one.
+    const stationBreaks = new StationBreaks({
+        dir: join(stateDir(), "ads"),
+        site: process.env["NIXAMP_SITE"] || "https://nixamp.com",
+        hasSlot: Boolean(process.env["AD_SLOT"]),
+        guard: (url) => refusedDestination(url),
+    });
     stationRunner = new StationRunner({
+        breaks: (video) => stationBreaks.next(video ? "video" : "audio"),
+        onRestart: (id) => stationUsage.restarted(id),
+        onFailure: (id) => stationUsage.failed(id),
         store: stationStore,
         channels,
         pull: async (channelId, name, files, known) => Boolean(await pullChannel(channels, tools.ffprobe, channelId, name, files[0], [], "", {
@@ -6181,7 +6223,66 @@ export async function serve(argv, version = "0.1.0") {
         roots: () => [...new Set([engine.snapshot(false).root || chosen, ...libraryIndex.roots()])].filter((one) => one !== ""),
         log: (line) => console.log(line),
     });
-    const stations = { store: stationStore, runner: stationRunner };
+    // Auto stations: a station per genre, kept in step with the library.
+    const autoSetting = () => {
+        const saved = readConfig().autoStations;
+        if (!saved)
+            return null;
+        const pick = (name) => (saved[name] === undefined ? DEFAULT_AUTO[name] : saved[name]);
+        return {
+            video: pick("video") !== false,
+            minItems: Number(pick("minItems")) || DEFAULT_AUTO.minItems,
+            minFilms: Number(pick("minFilms")) || DEFAULT_AUTO.minFilms,
+            start: pick("start") !== false,
+            maxVideoRunning: Number(pick("maxVideoRunning")) >= 0 ? Number(pick("maxVideoRunning")) : DEFAULT_AUTO.maxVideoRunning,
+            breaksEvery: Number(pick("breaksEvery")) >= 0 ? Number(pick("breaksEvery")) : DEFAULT_AUTO.breaksEvery,
+        };
+    };
+    let autoRunning = null;
+    const runAuto = (settings) => {
+        if (autoRunning)
+            return autoRunning;
+        autoRunning = syncAutoStations({
+            index: libraryIndex,
+            store: stationStore,
+            runner: stationRunner,
+            owner: options.owner || "",
+            mayStart: () => stationLimits.runningStations === 0 || stationStore.list().filter((one) => one.desired === "running").length < stationLimits.runningStations,
+            filmGenres: async (title) => {
+                const hit = await enricher.lookup(title, "title");
+                const genres = hit?.data?.["genres"];
+                return Array.isArray(genres) ? genres.filter((one) => typeof one === "string") : [];
+            },
+            log: (line) => console.log(line),
+        }, settings).then((report) => {
+            const made = report;
+            console.log(`  auto stations: ${made.radio.length} radio, ${made.tv.length} TV.`);
+            return report;
+        }).finally(() => { autoRunning = null; });
+        return autoRunning;
+    };
+    libraryIndex.onScanned = () => {
+        const settings = autoSetting();
+        if (settings)
+            void runAuto(settings);
+    };
+    const stationAuto = {
+        setting: () => autoSetting(),
+        sync: async (input) => {
+            if (input["off"] === true) {
+                writeConfig({ autoStations: undefined });
+                return { off: true };
+            }
+            const settings = { ...DEFAULT_AUTO, ...(autoSetting() ?? {}) };
+            for (const name of Object.keys(DEFAULT_AUTO)) {
+                if (input[name] !== undefined)
+                    settings[name] = input[name];
+            }
+            writeConfig({ autoStations: settings });
+            return runAuto(settings);
+        },
+    };
+    const stations = { store: stationStore, runner: stationRunner, usage: stationUsage, limits: stationLimits, auto: stationAuto };
     // Music handed over from BitTorrented, copied into a folder of our own.
     const importer = new Importer(join(stateDir(), `handoffs-${options.port}.json`), {
         index: libraryIndex,

package/dist/station-breaks.d.ts

@@ -0,0 +1,19 @@
+import { type Advert } from "./ads.ts";
+export interface BreakOptions {
+    dir: string;
+    /** nixamp.com, when this server has no slot of its own. */
+    site: string;
+    hasSlot: boolean;
+    guard: (url: string) => Promise<string>;
+    fetcher?: typeof fetch;
+    /** Injected by tests in place of the network. */
+    ask?: (kind: "audio" | "video") => Promise<Advert>;
+}
+export declare class StationBreaks {
+    private readonly options;
+    constructor(options: BreakOptions);
+    private ask;
+    /** A file to play for this break, or null for none. */
+    next(kind: "audio" | "video"): Promise<string | null>;
+    private cache;
+}

package/dist/station-breaks.js

@@ -0,0 +1,92 @@
+/**
+ * The break: a short spot between songs or films, instead of commercials.
+ *
+ * Asked for once per break, never per listener, and never in the middle of
+ * anything (playlist-input.ts places it between entries). Where it comes
+ * from, in order:
+ *
+ *   1. the ad network, through this server's own AD_SLOT (ads.ts), or
+ *      through nixamp.com's /api/ads/next when this server has none, so a
+ *      self-hosted station carries the same spot the site does and the
+ *      network meters the impression;
+ *   2. a house spot the operator dropped in $XDG_STATE_HOME/nixamp/ads/
+ *      (spot.mp4 for TV, spot.mp3 for radio);
+ *   3. nothing: no break this time, and the music goes on.
+ *
+ * A creative is fetched once per URL into ads/cache and played from disk:
+ * https only, public addresses only, at most 50 MB.
+ */
+import { createHash } from "node:crypto";
+import { createWriteStream, existsSync, mkdirSync, renameSync, rmSync } from "node:fs";
+import { extname, join } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { nextAdvert } from "./ads.js";
+const MAX_BYTES = 50 * 1024 * 1024;
+export class StationBreaks {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async ask(kind) {
+        if (this.options.ask)
+            return this.options.ask(kind);
+        if (this.options.hasSlot)
+            return nextAdvert(kind);
+        const send = this.options.fetcher ?? fetch;
+        try {
+            const answer = await send(`${this.options.site.replace(/\/+$/, "")}/api/ads/next?kind=${kind}`, { signal: AbortSignal.timeout(2_000) });
+            if (!answer.ok)
+                return { url: null };
+            const body = (await answer.json());
+            return typeof body.url === "string" ? { url: body.url, kind: body.kind === "video" ? "video" : "audio" } : { url: null };
+        }
+        catch {
+            return { url: null };
+        }
+    }
+    /** A file to play for this break, or null for none. */
+    async next(kind) {
+        const advert = await this.ask(kind);
+        if (advert.url) {
+            const cached = await this.cache(advert.url).catch(() => null);
+            if (cached)
+                return cached;
+        }
+        const house = join(this.options.dir, kind === "video" ? "spot.mp4" : "spot.mp3");
+        return existsSync(house) ? house : null;
+    }
+    async cache(url) {
+        const parsed = new URL(url);
+        if (parsed.protocol !== "https:")
+            return null;
+        const folder = join(this.options.dir, "cache");
+        const file = join(folder, `${createHash("sha1").update(url).digest("hex")}${extname(parsed.pathname).slice(0, 6) || ".mp4"}`);
+        if (existsSync(file))
+            return file;
+        if (await this.options.guard(url))
+            return null;
+        const answer = await (this.options.fetcher ?? fetch)(url, { signal: AbortSignal.timeout(20_000) });
+        if (!answer.ok || !answer.body)
+            return null;
+        if (Number(answer.headers.get("content-length") ?? 0) > MAX_BYTES)
+            return null;
+        mkdirSync(folder, { recursive: true });
+        const part = `${file}.part`;
+        let bytes = 0;
+        const counted = Readable.fromWeb(answer.body).on("data", (chunk) => {
+            bytes += chunk.length;
+            if (bytes > MAX_BYTES)
+                counted.destroy(new Error("too big"));
+        });
+        try {
+            await pipeline(counted, createWriteStream(part));
+            renameSync(part, file);
+            return file;
+        }
+        catch {
+            rmSync(part, { force: true });
+            return null;
+        }
+    }
+}

package/dist/station-cli.js

@@ -181,6 +181,28 @@ export async function station(argv) {
                     return [`page    ${links["page"]}`, `stream  ${links["stream"]}`, `m3u     ${links["m3u"]}`].join("\n");
                 });
             }
+            case "auto": {
+                const body = argv.includes("--off") ? { off: true } : {
+                    ...(argv.includes("--no-video") ? { video: false } : {}),
+                    ...(argv.includes("--no-start") ? { start: false } : {}),
+                    ...(flag(argv, "--min") ? { minItems: Number(flag(argv, "--min")) } : {}),
+                    ...(flag(argv, "--films") ? { minFilms: Number(flag(argv, "--films")) } : {}),
+                    ...(flag(argv, "--tv") ? { maxVideoRunning: Number(flag(argv, "--tv")) } : {}),
+                    ...(flag(argv, "--breaks") ? { breaksEvery: Number(flag(argv, "--breaks")) } : {}),
+                };
+                return show(await call("POST", "/api/v1/stations/auto", body), (answer) => {
+                    const report = answer["report"];
+                    if (report.off)
+                        return "Auto stations are off. The stations already made stay as they are.";
+                    const line = (one, unit) => `  ${String(one["genre"]).padEnd(16)} ${String(one["files"] ?? one["films"]).padStart(5)} ${unit}  ${one["running"] ? "on air" : "stopped"}${one["made"] ? "  (new)" : ""}  [${String(one["id"])}]`;
+                    return [
+                        "Radio:", ...(report.radio ?? []).map((one) => line(one, "files")),
+                        "TV:", ...((report.tv ?? []).length ? (report.tv ?? []).map((one) => line(one, "films")) : ["  none (no film genres known yet)"]),
+                        ...((report.skipped ?? []).length ? [`Too small for a station: ${(report.skipped ?? []).join(", ")}`] : []),
+                        "Every library scan keeps these up to date. They are unlisted: `nixamp station link ID` for a link.",
+                    ].join("\n");
+                });
+            }
             case "delete": {
                 const station = needId();
                 if (!station)

package/dist/station-guide.d.ts

@@ -0,0 +1,4 @@
+export declare const GUIDE_HTML = "<!doctype html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<title>Live \u00B7 stations</title>\n<meta name=\"description\" content=\"Radio and TV stations, live now.\">\n<link rel=\"icon\" href=\"data:,\">\n<style>\n:root{--bg:#f6f5f2;--fg:#17171a;--muted:#5d5d66;--card:#fff;--line:#dedcd6;--accent:#1f6feb;--live:#0b7a3b}\n@media (prefers-color-scheme:dark){:root{--bg:#121214;--fg:#ececf1;--muted:#a4a4b0;--card:#1c1c20;--line:#2c2c33;--accent:#6aa7ff;--live:#3fbf7f}}\n*{box-sizing:border-box}html,body{margin:0;background:var(--bg);color:var(--fg);font:16px/1.5 system-ui,-apple-system,\"Segoe UI\",sans-serif}\nmain{max-width:880px;margin:0 auto;padding:40px 16px}\nh1{margin:0 0 4px;font-size:1.8rem}p.lead{color:var(--muted);margin:0 0 24px}\nh2{font-size:1rem;letter-spacing:.06em;text-transform:uppercase;color:var(--muted);margin:28px 0 10px}\n.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(240px,1fr));gap:12px}\na.station{display:block;background:var(--card);border:1px solid var(--line);border-radius:14px;padding:16px;color:inherit;text-decoration:none}\na.station:hover,a.station:focus-visible{border-color:var(--accent);outline:none}\n.name{font-weight:700;font-size:1.05rem}.now{color:var(--muted);font-size:.9rem;margin-top:6px;min-height:1.4em}\n.live{color:var(--live);font-size:.8rem;font-weight:700}.empty{color:var(--muted)}\nfooter{margin-top:40px;color:var(--muted);font-size:.85rem}footer a{color:inherit}\n</style>\n</head>\n<body>\n<main>\n  <h1>Live</h1>\n  <p class=\"lead\">Radio and TV, on the air now. Pick one and press play.</p>\n  <h2 id=\"radio-title\" hidden>Radio</h2>\n  <div id=\"radio\" class=\"grid\" aria-live=\"polite\"></div>\n  <h2 id=\"tv-title\" hidden>TV</h2>\n  <div id=\"tv\" class=\"grid\" aria-live=\"polite\"></div>\n  <p id=\"empty\" class=\"empty\">Nothing is on the air here yet.</p>\n  <footer>Played by <a href=\"https://nixamp.com\">nixamp</a>, on the Moshpit.</footer>\n</main>\n<script>\n(async () => {\n  const el = (tag, cls, text) => { const n = document.createElement(tag); if (cls) n.className = cls; if (text) n.textContent = text; return n; };\n  const draw = (stations) => {\n    for (const [kind, box] of [[\"audio\", \"#radio\"], [\"video\", \"#tv\"]]) {\n      const grid = document.querySelector(box);\n      grid.replaceChildren();\n      const list = stations.filter((s) => s.kind === kind);\n      document.querySelector(box + \"-title\").hidden = list.length === 0;\n      for (const s of list) {\n        const a = el(\"a\", \"station\");\n        a.href = s.page;\n        a.append(el(\"div\", \"live\", s.state === \"live\" ? \"\u25CF LIVE\" : \"off the air\"), el(\"div\", \"name\", s.name),\n          el(\"div\", \"now\", s.nowPlaying ? [s.nowPlaying.title, s.nowPlaying.artist].filter(Boolean).join(\" \u2014 \") : \"\"));\n        grid.append(a);\n      }\n    }\n    document.querySelector(\"#empty\").hidden = stations.length > 0;\n  };\n  const load = async () => {\n    try {\n      const r = await fetch(\"/api/v1/stations/guide\", { cache: \"no-store\" });\n      if (r.ok) draw((await r.json()).stations);\n    } catch {}\n  };\n  await load();\n  setInterval(load, 15000);\n})();\n</script>\n</body>\n</html>\n";
+export declare const GUIDE_CSP: string;
+/** The hosts whose front page is the guide (NIXAMP_GUIDE_HOSTS, comma-separated). */
+export declare function guideHosts(env?: Record<string, string | undefined>): Set<string>;