nixamp 0.43.1 → 0.45.0

package/dist/guide-rooms.d.ts

@@ -0,0 +1,90 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { GuideEntry } from "./station-guide.ts";
+/** Why a room may be broadcast, the same five reasons a station gives. */
+export declare const ROOM_BASES: readonly ["owned", "permission", "licensed", "creative-commons", "public-domain"];
+export type RoomBasis = typeof ROOM_BASES[number];
+export interface GuideRoom {
+    id: string;
+    /** The room's stream address, with its listen key. */
+    play: string;
+    name: string;
+    kind: "audio" | "video";
+    basis: RoomBasis;
+    note: string;
+    /** The nixamp.com account that published it ("" for this server's owner). */
+    by: string;
+    publishedAt: number;
+}
+/** Rooms one member may have on the guide at once, and rooms on it in all. */
+export declare const ROOMS_PER_MEMBER = 5;
+export declare const ROOMS_MAX = 200;
+/**
+ * A room's address taken apart, or null when it is not one: https (http only
+ * for a loopback address, for tests), a channel or the live stream, a key,
+ * and nothing else in the query.
+ */
+export declare function roomAddress(input: string): {
+    origin: string;
+    channel: string | null;
+    key: string;
+    play: string;
+} | null;
+/** Where the guide links a room's page: config `watchBase`, NIXAMP_WATCH_BASE, else this server. */
+export declare function watchBase(fallback: string, env?: Record<string, string | undefined>): string;
+export declare const watchPage: (base: string, play: string) => string;
+export declare class RoomStore {
+    private readonly file;
+    private rooms;
+    constructor(file: string);
+    static fileFor(stateDir: string, port: number): string;
+    list(): GuideRoom[];
+    get(id: string): GuideRoom | undefined;
+    /** Publishes a room, or refreshes the one already published at that address. */
+    put(room: Omit<GuideRoom, "id" | "publishedAt">): GuideRoom;
+    remove(id: string): boolean;
+    private save;
+}
+export interface RoomState {
+    /** Whether the room's server says it is on the air. */
+    live: boolean;
+    name: string;
+    kind: "audio" | "video";
+    nowPlaying: {
+        title: string;
+        artist: string;
+    } | null;
+}
+/** Asks a room's own server what is on it: its channel list for a channel, the stream's headers for the live stream. */
+export declare class RoomProbe {
+    private readonly fetcher;
+    private readonly refuse;
+    private cache;
+    /**
+     * `refuse` names why an address may not be fetched from this machine (a
+     * private or loopback network), or "": a member chooses the address, and
+     * this server must not become their way into its own network.
+     */
+    constructor(fetcher?: typeof fetch, refuse?: (link: string) => Promise<string>);
+    state(play: string, fresh?: boolean): Promise<RoomState | null>;
+    private ask;
+}
+/** The rooms as guide cards: the page to open, on the air or not, and what is on. */
+export declare function roomEntries(store: RoomStore, probe: RoomProbe, base: string): Promise<GuideEntry[]>;
+export interface RoomContext {
+    store: RoomStore;
+    probe: RoomProbe;
+    /** The page base for a room's card. */
+    base: string;
+    /** Whether the request holds this server's control key (or is its signed-in owner). */
+    canControl: boolean;
+    /** The nixamp.com account behind the request's session, or "". */
+    member: () => Promise<string>;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    readBody: (request: IncomingMessage) => Promise<unknown>;
+    /** Refused by the caller's rate limit, or null. */
+    throttle?: () => {
+        retryAfter: number;
+    } | null;
+}
+/** Answers /api/v1/guide/rooms; false when the path is not one. */
+export declare function handleRooms(request: IncomingMessage, response: ServerResponse, path: string, ctx: RoomContext): Promise<boolean>;

package/dist/guide-rooms.js

@@ -0,0 +1,256 @@
+/**
+ * Live rooms on the station guide.
+ *
+ * A room is a channel, or the live stream, of any nixamp server: the address
+ * a Share or a "?play=" link carries, `https://host:port/api/channels/<id>?k=KEY`
+ * or `https://host:port/api/live?k=KEY`. A nixamp.com member publishes one with
+ * a rights basis, as a station is published; the guide lists it beside the
+ * stations, and its card opens /watch?play=<that address>, which plays it as
+ * a film or as radio, whichever it carries.
+ *
+ * Nothing here plays anything: the room's own server does, and this only asks
+ * it, now and then, whether the room is on the air and what is on it.
+ */
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import { readConfig } from "./library.js";
+/** Why a room may be broadcast, the same five reasons a station gives. */
+export const ROOM_BASES = ["owned", "permission", "licensed", "creative-commons", "public-domain"];
+/** Rooms one member may have on the guide at once, and rooms on it in all. */
+export const ROOMS_PER_MEMBER = 5;
+export const ROOMS_MAX = 200;
+const STATE_TTL_MS = 15_000;
+const PROBE_TIMEOUT_MS = 4_000;
+/**
+ * A room's address taken apart, or null when it is not one: https (http only
+ * for a loopback address, for tests), a channel or the live stream, a key,
+ * and nothing else in the query.
+ */
+export function roomAddress(input) {
+    let url;
+    try {
+        url = new URL(input.trim());
+    }
+    catch {
+        return null;
+    }
+    const loopback = url.hostname === "127.0.0.1" || url.hostname === "localhost";
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback))
+        return null;
+    if (url.username || url.password || url.hash)
+        return null;
+    const channel = /^\/api\/channels\/([A-Za-z0-9._~-]{1,120})\/?$/.exec(url.pathname);
+    const live = /^\/api\/live\/?$/.test(url.pathname);
+    if (!channel && !live)
+        return null;
+    const key = url.searchParams.get("k") ?? "";
+    if (!/^[A-Za-z0-9_-]{8,128}$/.test(key) || [...url.searchParams.keys()].some((name) => name !== "k"))
+        return null;
+    const path = channel ? `/api/channels/${channel[1]}` : "/api/live";
+    return { origin: url.origin, channel: channel ? channel[1] : null, key, play: `${url.origin}${path}?k=${key}` };
+}
+/** Where the guide links a room's page: config `watchBase`, NIXAMP_WATCH_BASE, else this server. */
+export function watchBase(fallback, env = process.env) {
+    const saved = (() => { try {
+        return readConfig().watchBase ?? "";
+    }
+    catch {
+        return "";
+    } })();
+    const chosen = (env["NIXAMP_WATCH_BASE"] || saved || fallback).trim().replace(/\/+$/, "");
+    return /^https?:\/\/[^\s"<>]+$/.test(chosen) ? chosen : fallback;
+}
+export const watchPage = (base, play) => `${base}/watch?play=${encodeURIComponent(play)}`;
+export class RoomStore {
+    file;
+    rooms = [];
+    constructor(file) {
+        this.file = file;
+        try {
+            if (existsSync(file)) {
+                const saved = JSON.parse(readFileSync(file, "utf8"));
+                this.rooms = (saved.rooms ?? []).filter((one) => roomAddress(one.play) !== null);
+            }
+        }
+        catch {
+            // Unreadable is empty; the next write replaces it.
+        }
+    }
+    static fileFor(stateDir, port) {
+        return join(stateDir, `guide-rooms-${port}.json`);
+    }
+    list() {
+        return [...this.rooms];
+    }
+    get(id) {
+        return this.rooms.find((one) => one.id === id);
+    }
+    /** Publishes a room, or refreshes the one already published at that address. */
+    put(room) {
+        const existing = this.rooms.find((one) => one.play === room.play);
+        const saved = { ...room, id: existing?.id ?? randomBytes(6).toString("base64url"), publishedAt: Date.now() };
+        this.rooms = [...this.rooms.filter((one) => one.play !== room.play), saved];
+        this.save();
+        return saved;
+    }
+    remove(id) {
+        const before = this.rooms.length;
+        this.rooms = this.rooms.filter((one) => one.id !== id);
+        if (this.rooms.length === before)
+            return false;
+        this.save();
+        return true;
+    }
+    save() {
+        writeFileSync(`${this.file}.part`, `${JSON.stringify({ version: 1, rooms: this.rooms }, null, 2)}\n`);
+        renameSync(`${this.file}.part`, this.file);
+    }
+}
+/** Asks a room's own server what is on it: its channel list for a channel, the stream's headers for the live stream. */
+export class RoomProbe {
+    fetcher;
+    refuse;
+    cache = new Map();
+    /**
+     * `refuse` names why an address may not be fetched from this machine (a
+     * private or loopback network), or "": a member chooses the address, and
+     * this server must not become their way into its own network.
+     */
+    constructor(fetcher = fetch, refuse = async () => "") {
+        this.fetcher = fetcher;
+        this.refuse = refuse;
+    }
+    async state(play, fresh = false) {
+        const cached = this.cache.get(play);
+        if (!fresh && cached && Date.now() - cached.at < STATE_TTL_MS)
+            return cached.state;
+        const state = await this.ask(play).catch(() => null);
+        this.cache.set(play, { at: Date.now(), state });
+        if (this.cache.size > 500)
+            this.cache.delete(this.cache.keys().next().value);
+        return state;
+    }
+    async ask(play) {
+        const address = roomAddress(play);
+        if (!address || (await this.refuse(address.play)) !== "")
+            return null;
+        if (address.channel !== null) {
+            const answer = await this.fetcher(`${address.origin}/api/channels?k=${address.key}`, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS), redirect: "error" });
+            if (!answer.ok)
+                return null;
+            const body = (await answer.json());
+            const row = (body.channels ?? []).find((one) => one.id === address.channel);
+            if (!row)
+                return null;
+            const tags = row.codecs?.tags;
+            return {
+                live: row.live !== false,
+                name: String(row.name ?? address.channel).replace(/\/+$/, "").slice(0, 120),
+                kind: row.kind === "video" ? "video" : "audio",
+                nowPlaying: tags && (tags.title || tags.artist) ? { title: String(tags.title ?? ""), artist: String(tags.artist ?? "") } : null,
+            };
+        }
+        // The live stream: on the air when it answers with media.
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+        try {
+            const answer = await this.fetcher(address.play, { signal: controller.signal, redirect: "error" });
+            const type = answer.headers.get("content-type") ?? "";
+            controller.abort();
+            if (!answer.ok)
+                return null;
+            return { live: true, name: "Live", kind: type.startsWith("video/") ? "video" : "audio", nowPlaying: null };
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/** The rooms as guide cards: the page to open, on the air or not, and what is on. */
+export async function roomEntries(store, probe, base) {
+    return Promise.all(store.list().map(async (room) => {
+        const state = await probe.state(room.play);
+        return {
+            id: room.id,
+            name: room.name,
+            kind: state?.kind ?? room.kind,
+            group: "rooms",
+            state: state?.live ? "live" : "offline",
+            page: watchPage(base, room.play),
+            nowPlaying: state?.nowPlaying ?? null,
+        };
+    }));
+}
+/** Answers /api/v1/guide/rooms; false when the path is not one. */
+export async function handleRooms(request, response, path, ctx) {
+    if (path !== "/api/v1/guide/rooms" && !path.startsWith("/api/v1/guide/rooms/"))
+        return false;
+    const method = request.method ?? "GET";
+    if (path === "/api/v1/guide/rooms" && (method === "GET" || method === "HEAD")) {
+        ctx.json(response, 200, { rooms: await roomEntries(ctx.store, ctx.probe, ctx.base) });
+        return true;
+    }
+    const by = ctx.canControl ? "" : await ctx.member();
+    if (!ctx.canControl && by === "") {
+        ctx.json(response, 401, { error: "sign in to nixamp.com to publish a live room", code: "sign_in" });
+        return true;
+    }
+    const refused = ctx.throttle?.();
+    if (refused) {
+        response.setHeader("retry-after", String(refused.retryAfter));
+        ctx.json(response, 429, { error: "too many changes; wait a moment", code: "throttled" });
+        return true;
+    }
+    if (path === "/api/v1/guide/rooms" && method === "POST") {
+        const body = (await ctx.readBody(request).catch(() => null));
+        const address = roomAddress(typeof body?.play === "string" ? body.play : "");
+        if (!address) {
+            ctx.json(response, 400, { error: "play must be a nixamp room's stream address: https://host/api/channels/<id>?k=KEY", code: "bad_address" });
+            return true;
+        }
+        const basis = ROOM_BASES.find((one) => one === body?.basis);
+        if (!basis || body?.agree !== true) {
+            ctx.json(response, 400, { error: "say why it may be broadcast (owned, permission, licensed, creative-commons or public-domain) and agree", code: "basis_required" });
+            return true;
+        }
+        const state = await ctx.probe.state(address.play, true);
+        if (!state) {
+            ctx.json(response, 404, { error: "that room is not on its server, or the key does not open it", code: "not_found" });
+            return true;
+        }
+        const all = ctx.store.list();
+        const mine = all.filter((one) => one.by === by && one.play !== address.play);
+        if (by !== "" && mine.length >= ROOMS_PER_MEMBER) {
+            ctx.json(response, 409, { error: `a member may have ${ROOMS_PER_MEMBER} rooms on the guide; take one off first`, code: "too_many" });
+            return true;
+        }
+        if (!all.some((one) => one.play === address.play) && all.length >= ROOMS_MAX) {
+            ctx.json(response, 409, { error: "the guide is full", code: "full" });
+            return true;
+        }
+        const taken = all.find((one) => one.play === address.play);
+        if (taken && taken.by !== by && !ctx.canControl) {
+            ctx.json(response, 409, { error: "somebody else published that room", code: "taken" });
+            return true;
+        }
+        const title = typeof body?.title === "string" ? body.title.trim().slice(0, 120) : "";
+        const note = typeof body?.note === "string" ? body.note.trim().slice(0, 300) : "";
+        const room = ctx.store.put({ play: address.play, name: title || state.name, kind: state.kind, basis, note, by: taken?.by ?? by });
+        ctx.json(response, 200, { room: { id: room.id, name: room.name, kind: room.kind, basis: room.basis }, page: watchPage(ctx.base, room.play) });
+        return true;
+    }
+    const one = /^\/api\/v1\/guide\/rooms\/([A-Za-z0-9_-]{1,32})$/.exec(path);
+    if (one && method === "DELETE") {
+        const room = ctx.store.get(one[1]);
+        if (!room || (!ctx.canControl && room.by !== by)) {
+            ctx.json(response, 404, { error: "no such room of yours on the guide", code: "not_found" });
+            return true;
+        }
+        ctx.store.remove(room.id);
+        ctx.json(response, 200, { removed: room.id });
+        return true;
+    }
+    ctx.json(response, 405, { error: "method not allowed", code: "method_not_allowed" });
+    return true;
+}

package/dist/library.d.ts

@@ -9,6 +9,14 @@ export interface Config {
     guideHosts?: string[];
     /** Other servers (https base addresses) whose public, listed stations this guide shows too. */
     guidePeers?: string[];
+    /** Where the guide links a published live room's page (https://live.streaming.pit.world); this server's own address when unset. */
+    watchBase?: string;
+    /** crawlproof on the guide: tracker project id (site), ad slot and format (`nixamp station guide-ads`). */
+    guideAds?: {
+        site?: string;
+        slot?: string;
+        format?: "banner_300x250" | "text_link";
+    };
     /** Station limits kept across restarts (station-metering.ts). */
     limits?: Record<string, unknown>;
     /** Proxies whose X-Forwarded-For is believed for listener shares (`nixamp station shares trust ADDRESS`). */

package/dist/library.js

@@ -35,6 +35,7 @@ export function readConfig() {
             ...(typeof record["limits"] === "object" && record["limits"] !== null ? { limits: record["limits"] } : {}),
             ...(Array.isArray(record["trustedProxies"]) ? { trustedProxies: record["trustedProxies"].filter((one) => typeof one === "string") } : {}),
             ...(Array.isArray(record["guideHosts"]) ? { guideHosts: record["guideHosts"].filter((one) => typeof one === "string") } : {}),
+            ...(typeof record["guideAds"] === "object" && record["guideAds"] !== null ? { guideAds: record["guideAds"] } : {}),
             ...(Array.isArray(record["guidePeers"]) ? { guidePeers: record["guidePeers"].filter((one) => typeof one === "string") } : {}),
         };
     }

package/dist/pit-footer.d.ts

@@ -0,0 +1,3 @@
+export declare function refreshPitFooter(): Promise<void>;
+/** The page with the footer before its last </body>, or the page unchanged. */
+export declare function withPitFooter(page: string): string;

package/dist/pit-footer.js

@@ -0,0 +1,40 @@
+/**
+ * The pit.world global footer (site name, search, ring, publish), fetched on
+ * the server and appended as the last thing in <body> of the nixamp.com pages.
+ *
+ * A module-level cache: the last good copy is served, and one older than an
+ * hour is refreshed in the background (3s timeout). A failed refresh keeps the
+ * old copy; with no copy at all the page goes out unchanged, so pit.world being
+ * down never breaks a page.
+ */
+const PIT_FOOTER_URL = "https://pit.world/snippets/footer.html?site=nixamp.com";
+const MAX_AGE_MS = 60 * 60 * 1000;
+let cached = "";
+let fetchedAt = 0;
+let inflight = null;
+export function refreshPitFooter() {
+    inflight ??= fetch(PIT_FOOTER_URL, { signal: AbortSignal.timeout(3000) })
+        .then(async (res) => {
+        const text = res.ok ? await res.text() : "";
+        if (!text.includes("data-pit-footer"))
+            throw new Error(`pit footer: HTTP ${res.status}`);
+        cached = text;
+        fetchedAt = Date.now();
+    })
+        .catch(() => {
+        fetchedAt = Date.now() - MAX_AGE_MS + 60_000; // try again in a minute
+    })
+        .finally(() => {
+        inflight = null;
+    });
+    return inflight;
+}
+/** The page with the footer before its last </body>, or the page unchanged. */
+export function withPitFooter(page) {
+    if (Date.now() - fetchedAt > MAX_AGE_MS)
+        void refreshPitFooter();
+    if (!cached || page.includes("data-pit-footer"))
+        return page;
+    const at = page.lastIndexOf("</body>");
+    return at < 0 ? page : page.slice(0, at) + cached + page.slice(at);
+}

package/dist/server.d.ts

@@ -27,6 +27,7 @@ import { Importer } from "./handoff.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { Support, SupportSubscriptions } from "./support.ts";
+import { RoomProbe, RoomStore } from "./guide-rooms.ts";
 import { PeerGuides } from "./station-guide.ts";
 import { StationRunner } from "./station-runner.ts";
 import { StationStore, type Station } from "./stations.ts";
@@ -616,6 +617,11 @@ export interface HandlerOptions {
         trustedProxies?: () => Set<string>;
         /** Other servers' public stations, for this guide to list beside its own. */
         peers?: PeerGuides;
+        /** Live rooms members published to this guide, and how to ask a room's server what is on it. */
+        rooms?: {
+            store: RoomStore;
+            probe: RoomProbe;
+        };
     };
     web: string | null;
     /** Branded clients on this same backend, keyed by an explicitly configured host. */

package/dist/server.js

@@ -68,8 +68,10 @@ import { SUPPORT_CSP, SUPPORT_PAGE, Support, SupportError, SupportSubscriptions,
 import { LyricsFinder } from "./lyrics.js";
 import { LyricsPublisher } from "./lyrics-publish.js";
 import { aiKey } from "./ai-keys.js";
-import { STATION_APP_CSP, STATION_PAGE, STATION_PAGE_CSP, STATION_PAGE_HTML } from "./station-page.js";
-import { GUIDE_CSP, guideHosts, guidePeers, peerBase, PeerGuides, renderGuide } from "./station-guide.js";
+import { STATION_APP_CSP, STATION_PAGE, STATION_PAGE_CSP, STATION_PAGE_HTML, WATCH_APP_CSP } from "./station-page.js";
+import { handleRooms, RoomProbe, roomEntries, RoomStore, watchBase } from "./guide-rooms.js";
+import { withPitFooter } from "./pit-footer.js";
+import { guideAds, guideCsp, guideHosts, guidePeers, peerBase, PeerGuides, renderGuide } from "./station-guide.js";
 import { StationRunner } from "./station-runner.js";
 import { StationError, StationStore, channelOf, stationOfChannel } from "./stations.js";
 import { STATION_CONTROL_LIMIT, StationUsage, limitsFromEnv } from "./station-metering.js";
@@ -2170,6 +2172,10 @@ export function createHandler(engine, options) {
             !/^\/support\/[a-z0-9-]{1,40}$/.test(path) && path !== "/support/cancel" && !/^\/api\/v1\/support\/[a-z0-9-]{1,40}$/.test(path) &&
             // A station's short link, which sends the browser to wherever it plays.
             !/^\/watch\/[a-z0-9]{10}$/.test(path) &&
+            // A live room's page: the room's own key travels in ?play=, checked by its server.
+            !(path === "/watch" && Boolean(options.stations?.rooms)) &&
+            // Live rooms on the guide: listed for anybody, published by a member (guide-rooms.ts).
+            !((path === "/api/v1/guide/rooms" || path.startsWith("/api/v1/guide/rooms/")) && Boolean(options.stations?.rooms)) &&
             !STATION_PAGE.test(path) &&
             !isPublicAsset &&
             !isGuidePage &&
@@ -2345,11 +2351,15 @@ export function createHandler(engine, options) {
             });
             const own = new Set(entries.map((one) => one.page));
             const others = options.stations.peers ? (await options.stations.peers.entries()).filter((one) => !own.has(one.page)) : [];
-            const page = renderGuide([...entries, ...others], options.stations.publicBase?.() ?? "");
+            const rooms = options.stations.rooms
+                ? await roomEntries(options.stations.rooms.store, options.stations.rooms.probe, watchBase(options.stations.publicBase?.() || `${encrypted ? "https" : "http"}://${request.headers.host ?? "localhost"}`))
+                : [];
+            const ads = guideAds();
+            const page = renderGuide([...rooms, ...entries, ...others], options.stations.publicBase?.() ?? "", ads);
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
-                "content-security-policy": GUIDE_CSP,
+                "content-security-policy": guideCsp(ads),
                 "referrer-policy": "no-referrer",
                 "x-content-type-options": "nosniff",
             });
@@ -2358,6 +2368,44 @@ export function createHandler(engine, options) {
         }
         // The page a station's link opens. The same bytes for every station: it
         // reads its id and token from its own address.
+        // A live room's page: /watch?play=<a nixamp server's channel or live
+        // stream address>. The built page plays it in @profullstack/player, as a
+        // film or as radio; nothing about the room passes through here.
+        if (options.stations?.rooms && path === "/watch" && (request.method === "GET" || request.method === "HEAD")) {
+            const built = web !== null && isFile(join(web, "watch.html")) ? readFileSync(join(web, "watch.html")) : null;
+            if (!built) {
+                json(response, 404, { error: "this server was started without its web pages" });
+                return;
+            }
+            response.writeHead(200, {
+                "content-type": "text/html; charset=utf-8",
+                "cache-control": "no-cache",
+                "content-security-policy": WATCH_APP_CSP,
+                "referrer-policy": "no-referrer",
+                "x-content-type-options": "nosniff",
+            });
+            response.end(request.method === "HEAD" ? undefined : built);
+            return;
+        }
+        if (options.stations?.rooms && (path === "/api/v1/guide/rooms" || path.startsWith("/api/v1/guide/rooms/"))) {
+            const control = await controlOf();
+            const session = tokenFrom(request.headers) || url.searchParams.get("session") || "";
+            const rooms = options.stations.rooms;
+            await handleRooms(request, response, path, {
+                store: rooms.store,
+                probe: rooms.probe,
+                base: watchBase(options.stations.publicBase?.() || `https://${request.headers.host ?? "localhost"}`),
+                canControl: control.allowed,
+                member: async () => (session && options.owner ? (await options.owner.accountFor(session)) || "" : ""),
+                json,
+                readBody,
+                throttle: () => {
+                    const verdict = guard.check(`rooms:${callerOf(request.headers, request.socket.remoteAddress, behindProxy)}`, STATION_CONTROL_LIMIT);
+                    return verdict.ok ? null : { retryAfter: verdict.retryAfter };
+                },
+            });
+            return;
+        }
         if (options.stations && STATION_PAGE.test(path) && (request.method === "GET" || request.method === "HEAD")) {
             // The built page plays in @profullstack/player; the inline one is for a
             // server started without the web build.
@@ -2474,6 +2522,9 @@ export function createHandler(engine, options) {
                 ...(options.stations.lyrics ? { lyrics: options.stations.lyrics } : {}),
                 ...(options.stations.lyricsPublisher ? { lyricsPublisher: options.stations.lyricsPublisher } : {}),
                 ...(options.stations.peers ? { peers: () => options.stations.peers.entries() } : {}),
+                ...(options.stations.rooms ? {
+                    rooms: () => roomEntries(options.stations.rooms.store, options.stations.rooms.probe, watchBase(options.stations.publicBase?.() || `${scheme}://${request.headers.host ?? "localhost"}`)),
+                } : {}),
                 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 };
@@ -5958,7 +6009,24 @@ export function createHandler(engine, options) {
                     }
                     const shell = subject ? readIfPossible(file) : null;
                     if (subject && shell !== null) {
-                        html(response, 200, joinDocument(shell, subject, eventSite ?? "https://nixamp.com"));
+                        html(response, 200, requestHost === "nixamp.com" ? withPitFooter(joinDocument(shell, subject, eventSite ?? "https://nixamp.com")) : joinDocument(shell, subject, eventSite ?? "https://nixamp.com"));
+                        return;
+                    }
+                }
+                // nixamp.com's own pages (the app shell, the radio console) carry the
+                // pit.world global footer, appended on the way out. A local install
+                // serving the same files on its own host is left alone.
+                if (requestHost === "nixamp.com" && file.endsWith(".html") && (request.method === "GET" || request.method === "HEAD")) {
+                    const shell = readIfPossible(file);
+                    if (shell !== null) {
+                        const page = withPitFooter(shell);
+                        response.writeHead(200, {
+                            ...CORS,
+                            "content-type": "text/html; charset=utf-8",
+                            "content-length": Buffer.byteLength(page),
+                            "cache-control": "no-cache",
+                        });
+                        response.end(request.method === "HEAD" ? undefined : page);
                         return;
                     }
                 }
@@ -6560,6 +6628,8 @@ export async function serve(argv, version = "0.1.0") {
             const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean).slice(0, 100) : [];
             return [...new Set([...guidePeers(), ...listed])];
         }),
+        // Live rooms published to this guide; the probe never reaches this machine's own network.
+        rooms: { store: new RoomStore(RoomStore.fileFor(stateDir(), options.port)), probe: new RoomProbe(fetch, (link) => refusedDestination(link)) },
     };
     // Music handed over from BitTorrented, copied into a folder of our own.
     const importer = new Importer(join(stateDir(), `handoffs-${options.port}.json`), {

package/dist/station-cli.js

@@ -207,6 +207,25 @@ export async function station(argv) {
                 console.log(hosts.size ? `The guide is the front page for: ${[...hosts].join(", ")}` : "No host shows the guide as its front page (it is still at /guide).");
                 return 0;
             }
+            case "guide-ads": {
+                // crawlproof analytics + an ad unit on the guide; read by the daemon on every request.
+                const { readConfig, writeConfig } = await import("./library.js");
+                const { cleanGuideAds } = await import("./station-guide.js");
+                const raw = argv.includes("--off") ? {} : { ...(readConfig().guideAds ?? {}), ...Object.fromEntries(["site", "slot", "format"].flatMap((name) => { const value = flag(argv, `--${name}`); return value === undefined ? [] : [[name, value]]; })) };
+                const next = cleanGuideAds(raw);
+                for (const name of ["site", "slot"]) {
+                    if (typeof raw[name] === "string" && raw[name] !== "" && !next[name]) {
+                        console.error(`--${name} is a crawlproof id (letters, digits and dashes)`);
+                        return 2;
+                    }
+                }
+                writeConfig({ guideAds: next });
+                console.log([
+                    next.site ? `Tracker   crawlproof project ${next.site}` : "Tracker   off",
+                    next.slot ? `Ad        crawlproof slot ${next.slot} (${next.format ?? "banner_300x250"})` : "Ad        off",
+                ].join("\n"));
+                return 0;
+            }
             case "guide-peer": {
                 // Another server whose public, listed stations this guide shows too.
                 const { readConfig, writeConfig } = await import("./library.js");

package/dist/station-guide.d.ts

@@ -11,8 +11,8 @@ export interface GuideEntry {
     id?: string;
     name: string;
     kind: "audio" | "video";
-    /** ai, shared, radio or tv; from kind when absent. */
-    group?: "ai" | "shared" | "radio" | "tv";
+    /** rooms (live rooms, src/guide-rooms.ts), ai, shared, radio or tv; from kind when absent. */
+    group?: "rooms" | "ai" | "shared" | "radio" | "tv";
     state: string;
     page: string;
     nowPlaying: {
@@ -27,9 +27,30 @@ export interface GuideEntry {
  * gateway that cannot run its script against this server (the Moshpit's
  * /n/<name>), and for a crawler. Everything from a station is escaped.
  */
-export declare function renderGuide(entries: GuideEntry[], apiBase?: string): string;
+export declare function renderGuide(entries: GuideEntry[], apiBase?: string, ads?: GuideAds): string;
 export declare const GUIDE_HTML: string;
+/**
+ * The guide's policy. With crawlproof configured (guideAds below) its tracker
+ * script and its ad frame are allowed from crawlproof.com and nothing else
+ * changes; the tracker reports by fetch, which connect-src https: already allows.
+ */
+export declare function guideCsp(ads?: GuideAds): string;
 export declare const GUIDE_CSP: string;
+/** crawlproof analytics and an ad on the guide: a project id (tracker data-site) and an ad slot. */
+export interface GuideAds {
+    site?: string;
+    slot?: string;
+    format?: "banner_300x250" | "text_link";
+}
+/** A setting as the guide may use it: ids that are ids, a format it knows, or nothing. */
+export declare function cleanGuideAds(value: unknown): GuideAds;
+/**
+ * crawlproof on the guide: `guideAds` in config.json (`nixamp station guide-ads
+ * --site ID --slot ID`), each overridden by NIXAMP_GUIDE_CRAWLPROOF_SITE /
+ * NIXAMP_GUIDE_AD_SLOT / NIXAMP_GUIDE_AD_FORMAT. Unset is off: a guide on
+ * somebody's own machine carries nobody's tracker.
+ */
+export declare function guideAds(env?: Record<string, string | undefined>): GuideAds;
 /**
  * The hosts whose front page is the guide: `guideHosts` in config.json
  * (`nixamp station guide-host NAME`, which survives restarts and updates),