nixamp 0.48.1 → 0.50.1

package/dist/music-store.js

@@ -0,0 +1,289 @@
+/**
+ * The music store on nixamp.com: the AI label's songs as files, bought with
+ * crypto through CoinPay.
+ *
+ * Listening is free on the live stations (with their breaks). What is sold is
+ * the files: a song for 10 cents, an album for $1, everything by an artist
+ * for $2, as a zip made on the fly by the server that holds them (MP3s with
+ * the cover and the words inside, each song's .lyrics.txt, cover.jpg and
+ * album.json). A buyer gives an email; once CoinPay says paid (its webhook,
+ * or asked when the buyer comes back), the email gets a link to the purchase,
+ * and the account with that email sees every purchase under My music on
+ * nixamp.com/radio, to play or download again.
+ *
+ * nixamp.com never holds the music. It signs a grant -- what was bought, from
+ * which server, until when -- and the server asks nixamp.com whether a grant
+ * is good before it plays or zips anything (/api/v1/store/grant).
+ */
+import { createHmac, randomUUID, timingSafeEqual } from "node:crypto";
+import { SupportError } from "./support.js";
+/** In cents. */
+export const PRICES = { song: 10, album: 100, artist: 200 };
+const EMAIL = /^[^\s@<>"]{1,64}@[^\s@<>"]{1,190}\.[a-z]{2,24}$/i;
+const KEY = /^[a-f0-9]{10}$/;
+const ALBUM = /^[a-f0-9]{8}$/;
+/** A grant is good for a day; pages mint a fresh one each time. */
+const GRANT_MS = 24 * 3600_000;
+/** A server's public address as given: https, no path, no trailing slash. */
+export function serverBase(value) {
+    if (typeof value !== "string")
+        return "";
+    try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" || url.username || url.password)
+            return "";
+        return url.origin;
+    }
+    catch {
+        return "";
+    }
+}
+function sign(secret, text) {
+    return createHmac("sha256", secret).update(text).digest("base64url");
+}
+/** `g1.<exp>.<kind>.<artist>.<album|->.<n>.<server, base64url>.<sig>` */
+export function makeGrant(secret, scope, exp) {
+    const body = ["g1", String(exp), scope.kind, scope.artist, scope.album || "-", String(scope.n), Buffer.from(scope.server).toString("base64url")].join(".");
+    return `${body}.${sign(secret, body)}`;
+}
+export function readGrant(secret, grant, now = Date.now()) {
+    const parts = grant.split(".");
+    if (parts.length !== 8 || parts[0] !== "g1")
+        return null;
+    const body = parts.slice(0, 7).join(".");
+    const expected = Buffer.from(sign(secret, body));
+    const given = Buffer.from(parts[7]);
+    if (expected.length !== given.length || !timingSafeEqual(expected, given))
+        return null;
+    const exp = Number(parts[1]);
+    if (!Number.isFinite(exp) || exp < now)
+        return null;
+    const kind = parts[2];
+    if (!(kind in PRICES))
+        return null;
+    return { kind, artist: parts[3], album: parts[4] === "-" ? "" : parts[4], n: Number(parts[5]), server: Buffer.from(parts[6], "base64url").toString("utf8"), exp };
+}
+/** Whether a grant for `scope` covers this file of the catalogue. */
+export function covers(scope, artist, album, n) {
+    if (scope.artist !== artist)
+        return false;
+    if (scope.kind === "artist")
+        return true;
+    if (scope.album !== album)
+        return false;
+    if (scope.kind === "album")
+        return true;
+    return n === undefined ? false : scope.n === n;
+}
+/**
+ * On a server that holds the music: whether nixamp.com signed this grant,
+ * asked at /api/v1/store/grant and remembered (a good one until it expires,
+ * a refused one for 5 minutes). nixamp.com itself checks with its secret.
+ */
+export class GrantVerifier {
+    options;
+    known = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async check(grant) {
+        const now = this.options.now?.() ?? Date.now();
+        if (!/^g1\.[A-Za-z0-9._-]{20,600}$/.test(grant))
+            return null;
+        if (this.options.secret)
+            return readGrant(this.options.secret, grant, now);
+        const hit = this.known.get(grant);
+        if (hit && hit.until > now)
+            return hit.scope;
+        try {
+            const response = await (this.options.fetcher ?? fetch)(`${this.options.site}/api/v1/store/grant?g=${encodeURIComponent(grant)}`, { signal: AbortSignal.timeout(5_000) });
+            if (response.status >= 500)
+                return null;
+            const body = await response.json();
+            const scope = body.ok && body.scope ? body.scope : null;
+            if (this.known.size > 5000)
+                this.known.clear();
+            this.known.set(grant, { scope, until: scope ? scope.exp : now + 5 * 60_000 });
+            return scope;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function row(one) {
+    return {
+        id: String(one["id"]), token: String(one["token"]), email: String(one["email"]), userId: String(one["user_id"] ?? ""),
+        server: String(one["server"]), kind: String(one["kind"]), artist: String(one["artist"]), album: String(one["album"] ?? ""), n: Number(one["n"] ?? 0),
+        title: String(one["title"]), artistName: String(one["artist_name"]), amountCents: Number(one["amount_cents"]), coin: String(one["coin"]),
+        paymentId: String(one["payment_id"] ?? ""), status: one["status"] === "paid" ? "paid" : "pending",
+        createdAt: new Date(String(one["created_at"])).getTime(), paidAt: one["paid_at"] ? new Date(String(one["paid_at"])).getTime() : 0,
+    };
+}
+export class MusicStore {
+    options;
+    schema = null;
+    constructor(options) {
+        this.options = options;
+    }
+    now() {
+        return this.options.now?.() ?? Date.now();
+    }
+    ready() {
+        this.schema ??= (async () => {
+            await this.options.db.query(`CREATE TABLE IF NOT EXISTS music_purchases (
+        id TEXT PRIMARY KEY, token TEXT NOT NULL, email TEXT NOT NULL, user_id TEXT NOT NULL DEFAULT '',
+        server TEXT NOT NULL, kind TEXT NOT NULL, artist TEXT NOT NULL, album TEXT NOT NULL DEFAULT '', n INTEGER NOT NULL DEFAULT 0,
+        title TEXT NOT NULL, artist_name TEXT NOT NULL, amount_cents INTEGER NOT NULL, coin TEXT NOT NULL,
+        payment_id TEXT, status TEXT NOT NULL DEFAULT 'pending', created_at TIMESTAMPTZ NOT NULL, paid_at TIMESTAMPTZ)`);
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_email ON music_purchases (lower(email))");
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_user ON music_purchases (user_id)");
+            await this.options.db.query("CREATE INDEX IF NOT EXISTS music_purchases_payment ON music_purchases (payment_id)");
+        })().catch((error) => { this.schema = null; throw error; });
+        return this.schema;
+    }
+    /** A server's catalogue, as it publishes it at /api/v1/label. */
+    async catalogue(server) {
+        const response = await (this.options.fetcher ?? fetch)(`${server}/api/v1/label`, { signal: AbortSignal.timeout(10_000), headers: { accept: "application/json" } });
+        if (!response.ok)
+            throw new SupportError("That server's catalogue could not be read. Try again.", 502, "catalogue");
+        return await response.json();
+    }
+    /** What is for sale at this address, with its name and price; refused when there is no such thing. */
+    async describe(input) {
+        const server = serverBase(input["server"]);
+        // A server in the directory or the guide's peers, or one named under nixamp.com (whose names
+        // and certificates nixamp.com issues): the directory empties on every restart of nixamp.com.
+        const named = server ? new URL(server).hostname.endsWith(".nixamp.com") : false;
+        if (!server || !(named || this.options.servers().includes(server)))
+            throw new SupportError("That server does not sell music here.", 404, "not_found");
+        const kind = String(input["kind"] ?? "");
+        if (!(kind in PRICES))
+            throw new SupportError("Buy a song, an album or an artist.", 400, "invalid_kind");
+        const artistKey = String(input["artist"] ?? "");
+        const albumKey = kind === "artist" ? "" : String(input["album"] ?? "");
+        const n = kind === "song" ? Number(input["n"]) : 0;
+        if (!KEY.test(artistKey) || (kind !== "artist" && !ALBUM.test(albumKey)) || (kind === "song" && !(Number.isInteger(n) && n > 0)))
+            throw new SupportError("No such music.", 404, "not_found");
+        const view = await this.catalogue(server);
+        const artist = view.genres.flatMap((one) => one.artists).find((one) => one.key === artistKey);
+        const album = artist?.albums.find((one) => one.key === albumKey);
+        const song = album?.songs.find((one) => one.n === n);
+        if (!artist || (kind !== "artist" && !album) || (kind === "song" && !song))
+            throw new SupportError("No such music.", 404, "not_found");
+        const title = kind === "artist" ? `Everything by ${artist.name}` : kind === "album" ? `${album.title} (${album.year})` : `${song.title}`;
+        const songs = kind === "artist" ? artist.albums.reduce((sum, one) => sum + one.songs.length, 0) : kind === "album" ? album.songs.length : 1;
+        return { server, kind, artist: artistKey, album: albumKey, n, title, artistName: artist.name, amountCents: PRICES[kind], songs };
+    }
+    /** A purchase waiting for its payment, and where to pay. Signed in, it is the account's too. */
+    async checkout(input, account) {
+        const email = (typeof input["email"] === "string" && input["email"].trim() ? input["email"] : account?.email ?? "").trim().toLowerCase();
+        if (!EMAIL.test(email))
+            throw new SupportError("Give the email your music should go to.", 400, "invalid_email");
+        const item = await this.describe(input);
+        await this.ready();
+        const id = randomUUID();
+        const token = randomUUID().replace(/-/g, "");
+        const checkout = await this.options.support.pay({
+            amountUsd: item.amountCents / 100,
+            coin: input["coin"],
+            order: `music-${id}`,
+            description: `${item.title} by ${item.artistName} (${item.kind === "song" ? "song" : item.kind === "album" ? "album" : "every album"}, MP3)`,
+            metadata: { product: "music", purchase: id, kind: item.kind },
+            redirect: this.link(id, token),
+        });
+        await this.options.db.query(`INSERT INTO music_purchases (id, token, email, user_id, server, kind, artist, album, n, title, artist_name, amount_cents, coin, payment_id, created_at)
+      VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)`, [id, token, email, account?.id ?? "", item.server, item.kind, item.artist, item.album, item.n, item.title, item.artistName, item.amountCents, String(input["coin"]).toUpperCase(), checkout.paymentId, new Date(this.now())]);
+        return { url: checkout.url, id, token };
+    }
+    /** The purchase's own page, which is also the receipt link. */
+    link(id, token) {
+        return `${this.options.site}/purchases/${id}?t=${token}`;
+    }
+    /** A purchase by its link; a pending one asks CoinPay whether it has been paid since. */
+    async get(id, token) {
+        await this.ready();
+        const found = (await this.options.db.query("SELECT * FROM music_purchases WHERE id = $1 AND token = $2", [id, token])).rows[0];
+        if (!found)
+            return null;
+        const purchase = row(found);
+        if (purchase.status === "pending" && purchase.paymentId && (await this.options.support.isPaid(purchase.paymentId)) === true)
+            return (await this.paid(purchase.id)) ?? purchase;
+        return purchase;
+    }
+    /** CoinPay's webhook: a payment of ours that is now paid. False when it is not a music purchase. */
+    async settle(paymentId) {
+        await this.ready();
+        const found = (await this.options.db.query("SELECT id, status FROM music_purchases WHERE payment_id = $1", [paymentId])).rows[0];
+        if (!found)
+            return { settled: false };
+        if (found["status"] === "paid")
+            return { settled: true, purchase: String(found["id"]) };
+        if ((await this.options.support.isPaid(paymentId)) !== true)
+            return { settled: false, purchase: String(found["id"]) };
+        await this.paid(String(found["id"]));
+        return { settled: true, purchase: String(found["id"]) };
+    }
+    /** Whether CoinPay's webhook is about one of ours. */
+    async owns(paymentId) {
+        await this.ready();
+        return (await this.options.db.query("SELECT 1 FROM music_purchases WHERE payment_id = $1", [paymentId])).rows.length > 0;
+    }
+    /** Marks it paid once (the first to get there sends the receipt). */
+    async paid(id) {
+        const updated = (await this.options.db.query("UPDATE music_purchases SET status = 'paid', paid_at = $2 WHERE id = $1 AND status = 'pending' RETURNING *", [id, new Date(this.now())])).rows[0];
+        if (!updated) {
+            const again = (await this.options.db.query("SELECT * FROM music_purchases WHERE id = $1", [id])).rows[0];
+            return again ? row(again) : null;
+        }
+        const purchase = row(updated);
+        await this.mail(purchase.email, `Your music: ${purchase.title}`, [
+            `Thank you. "${purchase.title}" by ${purchase.artistName} is yours: MP3s with the cover art and the lyrics, in one zip.`,
+            `Download it, now or any time: ${this.link(purchase.id, purchase.token)}`,
+            `Sign in to nixamp.com with ${purchase.email} and everything you have bought is under My music on ${this.options.site}/radio#music, to play or download again.`,
+        ]);
+        return purchase;
+    }
+    /** Every paid purchase of this account: made signed in, or to its email. */
+    async forAccount(account) {
+        await this.ready();
+        const rows = await this.options.db.query("SELECT * FROM music_purchases WHERE status = 'paid' AND (user_id = $1 OR lower(email) = lower($2)) ORDER BY paid_at DESC LIMIT 500", [account.id, account.email]);
+        return rows.rows.map(row);
+    }
+    grant(purchase) {
+        return makeGrant(this.options.secret, purchase, this.now() + GRANT_MS);
+    }
+    check(grant) {
+        return readGrant(this.options.secret, grant, this.now());
+    }
+    /** Where the zip of a purchase is made: on the server that holds the music. */
+    zipUrl(purchase) {
+        return `${purchase.server}/api/v1/label/zip?grant=${encodeURIComponent(this.grant(purchase))}`;
+    }
+    /** What anybody with the purchase's link (or the account) is shown. */
+    view(purchase) {
+        return {
+            id: purchase.id, kind: purchase.kind, title: purchase.title, artistName: purchase.artistName, server: purchase.server,
+            artist: purchase.artist, album: purchase.album, n: purchase.n, amountUsd: purchase.amountCents / 100, coin: purchase.coin,
+            status: purchase.status, createdAt: purchase.createdAt, paidAt: purchase.paidAt,
+            ...(purchase.status === "paid" ? { grant: this.grant(purchase), zip: this.zipUrl(purchase), link: this.link(purchase.id, purchase.token) } : {}),
+        };
+    }
+    async mail(to, subject, lines) {
+        if (!this.options.mail) {
+            this.options.log?.(`  store: no RESEND_API_KEY, so "${subject}" to ${to} was not sent`);
+            return;
+        }
+        try {
+            await (this.options.fetcher ?? fetch)("https://api.resend.com/emails", {
+                method: "POST",
+                signal: AbortSignal.timeout(15_000),
+                headers: { authorization: `Bearer ${this.options.mail.apiKey}`, "content-type": "application/json" },
+                body: JSON.stringify({ from: this.options.mail.from, to: [to], subject, text: `${lines.join("\n\n")}\n\nnixamp.com` }),
+            });
+        }
+        catch (error) {
+            this.options.log?.(`  store: mail to ${to} failed: ${error.message}`);
+        }
+    }
+}

package/dist/server.d.ts

@@ -24,6 +24,8 @@ import { HlsPackagers } from "./hls.ts";
 import { LibraryIndex, type Probed } from "./library-index.ts";
 import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
+import { AiLabel } from "./ai-label.ts";
+import { MusicStore } from "./music-store.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { Support, SupportSubscriptions } from "./support.ts";
@@ -599,6 +601,8 @@ export interface HandlerOptions {
         publicBase?: () => string;
         /** Stations whose music is composed by AI. */
         ai?: AiRadio;
+        /** AI artists and their albums, a genre station each, and the catalogue at /label. */
+        label?: AiLabel;
         /** Tracks anybody may share, sorted onto the air by AI. */
         shares?: ListenerShares;
         /** What a listener may know about the track on the air. */
@@ -827,6 +831,8 @@ export interface HandlerOptions {
     supportSubscriptions?: SupportSubscriptions;
     /** Signing secret of nixamp's CoinPay business, for /api/v1/webhooks/coinpay. */
     coinpayWebhookSecret?: string;
+    /** The AI label's songs for sale, nixamp.com only (music-store.ts). */
+    musicStore?: MusicStore;
     sharedTranslations?: SharedTranslations;
     /** Translation: texts in another language, by a model here. The same optional library. */
     translator?: Translator;

package/dist/server.js

@@ -61,6 +61,10 @@ import { ListenerStore } from "./library-user.js";
 import { Importer } from "./handoff.js";
 import { handleHandoffs } from "./handoff-routes.js";
 import { handleAiRoutes, isPublicSharePath } from "./ai-routes.js";
+import { AiLabel } from "./ai-label.js";
+import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.js";
+import { GrantVerifier, MusicStore } from "./music-store.js";
+import { handleStoreRoutes, isStorePath } from "./store-routes.js";
 import { AiRadio } from "./ai-radio.js";
 import { ListenerShares } from "./listener-shares.js";
 import { HolderStore, TagReader, factsFor } from "./track-facts.js";
@@ -1489,6 +1493,9 @@ export function createHandler(engine, options) {
         site: process.env["NIXAMP_SITE"] || "https://nixamp.com",
         ...(listenPassKey ? { secret: listenPassKey } : {}),
     });
+    // The music store lives on nixamp.com; a server holding the label's music asks it about grants.
+    const storeSite = (process.env["NIXAMP_SITE"] || "https://nixamp.com").replace(/\/+$/, "");
+    const storeGrants = new GrantVerifier({ site: storeSite });
     return async function handle(request, response) {
         const url = new URL(request.url ?? "/", "http://localhost");
         const path = url.pathname;
@@ -2055,6 +2062,19 @@ export function createHandler(engine, options) {
                 json(response, 400, { error: "invalid JSON" });
                 return;
             }
+            if (options.musicStore) {
+                try {
+                    if (await options.musicStore.owns(event.paymentId)) {
+                        json(response, 200, await options.musicStore.settle(event.paymentId));
+                        return;
+                    }
+                }
+                catch (error) {
+                    console.error(`nixamp: CoinPay webhook for ${event.paymentId} (music) could not settle: ${error instanceof Error ? error.message : String(error)}`);
+                    json(response, 500, { error: "could not settle; retry" });
+                    return;
+                }
+            }
             if (!options.translationPasses) {
                 json(response, 200, { settled: false, reason: "billing is off here" });
                 return;
@@ -2177,6 +2197,10 @@ export function createHandler(engine, options) {
             !isStationListenPath(path) &&
             // Sharing a track and reporting one are for anybody the guide reaches.
             !isPublicSharePath(path) &&
+            // The AI label's catalogue, its songs and their words.
+            !(isPublicLabelPath(path) && Boolean(options.stations?.label)) &&
+            // The music store: its pages, checkout, receipts and grants (nixamp.com).
+            !(isStorePath(path) && Boolean(options.musicStore)) &&
             // What is on, as MCP, for anybody.
             path !== "/mcp/public" &&
             // Supporting a copyright holder is for anybody listening.
@@ -2368,7 +2392,8 @@ export function createHandler(engine, options) {
                 ? 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);
+            const label = options.stations.label;
+            const page = renderGuide([...rooms, ...entries, ...others], options.stations.publicBase?.() ?? "", ads, label && label.publicView().genres.length > 0 ? "/label" : "");
             response.writeHead(200, {
                 "content-type": "text/html; charset=utf-8",
                 "cache-control": "no-cache",
@@ -2523,6 +2548,26 @@ export function createHandler(engine, options) {
             });
             return;
         }
+        if (options.musicStore && options.support && isStorePath(path)) {
+            const support = options.support;
+            const accounts = options.accounts;
+            if (await handleStoreRoutes(request, response, path, url, {
+                store: options.musicStore,
+                coins: async () => (await support.coins()).coins,
+                account: async () => (accounts ? await accounts.whoIs(tokenFrom(request.headers)) : null),
+                json,
+                readBody,
+            }))
+                return;
+        }
+        if (options.stations?.label && (isPublicLabelPath(path) || path === "/api/v1/stations/label" || path.startsWith("/api/v1/stations/label/"))) {
+            const control = isPublicLabelPath(path) ? { allowed: false } : await controlOf();
+            if (await handleLabelRoutes(request, response, path, {
+                label: options.stations.label, canControl: control.allowed, json, readBody,
+                grants: storeGrants, site: storeSite, publicBase: options.stations.publicBase?.() ?? "",
+            }))
+                return;
+        }
         if (options.stations && (isPublicSharePath(path) || path.startsWith("/api/v1/stations/ai") || path.startsWith("/api/v1/stations/shares") || path.startsWith("/api/v1/stations/holders"))) {
             const control = await controlOf();
             // Behind a proxy we trust (dev2 for live.streaming), the sharer is the
@@ -6771,10 +6816,27 @@ export async function serve(argv, version = "0.1.0") {
         ffmpeg: tools.ffmpeg,
         root: join(stateDir(), "ai-music"),
         owner: options.owner || "",
+        holder: () => aiLabel.holder(),
+        mayStart: mayStartStation,
+        log: (line) => console.log(line),
+    });
+    // The AI label: artists who put out albums on their own, filed under the
+    // library as ai/<genre>/<artist>/<year>-<album>/ (NIXAMP_LABEL_ROOT moves it).
+    const labelHome = libraryIndex.sources().find((one) => one.enabled && !one.managed);
+    const aiLabel = new AiLabel(AiLabel.fileFor(stateDir(), options.port), {
+        index: libraryIndex,
+        store: stationStore,
+        runner: stationRunner,
+        probe: probeFile,
+        ffmpeg: tools.ffmpeg,
+        root: process.env["NIXAMP_LABEL_ROOT"] || (labelHome ? join(labelHome.root, "ai") : join(stateDir(), "ai-label")),
+        owner: options.owner || "",
         mayStart: mayStartStation,
         log: (line) => console.log(line),
     });
     aiRadio.startSchedule();
+    aiLabel.startSchedule();
+    stations.label = aiLabel;
     // Tracks anybody shares from the guide, checked by AI before they air.
     const listenerShares = new ListenerShares(ListenerShares.fileFor(stateDir(), options.port), {
         index: libraryIndex,
@@ -6853,16 +6915,27 @@ export async function serve(argv, version = "0.1.0") {
         }
         const art = picture ? `/api/v1/stations/${station.id}/art?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` : "";
         const words = await lyricsFinder.find(file).catch(() => null);
-        return factsFor({
-            art,
-            ...(words ? { lyrics: `/api/v1/stations/${station.id}/lyrics?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` } : {}),
-            station, file,
-            tags: await tagReader.read(file),
-            known: trackFor(engine, file),
-            holders: holderStore.list(),
-            share: share ? { basis: share.rights.basis, note: share.rights.note, by: share.by } : null,
-            aiTrack: composed ? { made: composed.made } : null,
-        });
+        // A label song is for sale on nixamp.com: the song, its album, everything by the artist.
+        const song = aiLabel.songAt(file);
+        const here = stations.publicBase?.() ?? "";
+        const shop = (process.env["NIXAMP_SITE"] || "https://nixamp.com").replace(/\/+$/, "");
+        const store = song && /^https:\/\//.test(here) ? {
+            song: buyLink(shop, here, "song", song.artist, song.album, song.n),
+            album: buyLink(shop, here, "album", song.artist, song.album),
+            artist: buyLink(shop, here, "artist", song.artist),
+            artistName: song.artistName,
+            albumTitle: song.albumTitle,
+        } : null;
+        return { ...factsFor({
+                art,
+                ...(words ? { lyrics: `/api/v1/stations/${station.id}/lyrics?t=${encodeURIComponent(station.listenToken)}&f=${sha("sha1").update(file + stamp).digest("hex").slice(0, 12)}` } : {}),
+                station, file,
+                tags: await tagReader.read(file),
+                known: trackFor(engine, file),
+                holders: holderStore.list(),
+                share: share ? { basis: share.rights.basis, note: share.rights.note, by: share.by } : null,
+                aiTrack: composed ? { made: composed.made } : null,
+            }), store };
     };
     // Channels as HLS, on demand, for Safari on a phone: one ffmpeg copying a
     // channel's fragments into short files while somebody is asking for them.
@@ -7002,6 +7075,20 @@ export async function serve(argv, version = "0.1.0") {
         log: (line) => console.log(line),
     }) : undefined;
     supportMonthly?.startSchedule();
+    // The AI label's songs for sale: purchases kept here, the music zipped by the server that holds it.
+    const jwtSecret = process.env["NIXAMP_JWT_SECRET"] ?? "";
+    const musicStore = supportPayments && supportPayments.enabled && pool && jwtSecret ? new MusicStore({
+        db: pool,
+        support: supportPayments,
+        mail: process.env["RESEND_API_KEY"] ? { apiKey: process.env["RESEND_API_KEY"], from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>" } : null,
+        site: nixampSite,
+        secret: sha("sha256").update(`music-grant:${jwtSecret}`).digest("hex"),
+        servers: () => {
+            const listed = directory ? directory.list().map((one) => peerBase(one.url)).filter(Boolean) : [];
+            return [...new Set([...guidePeers(), ...listed])];
+        },
+        log: (line) => console.log(line),
+    }) : undefined;
     if (translationPasses)
         void translationPasses.access().catch(() => console.error("nixamp: translation checkout could not warm; it will retry on demand"));
     const liveVoice = accounts && process.env["NIXAMP_DUBBING"] !== "off" ? new LiveVoice({
@@ -7552,6 +7639,7 @@ export async function serve(argv, version = "0.1.0") {
         ...(translationPasses ? { translationPasses } : {}),
         ...(supportPayments ? { support: supportPayments } : {}),
         ...(supportMonthly ? { supportSubscriptions: supportMonthly } : {}),
+        ...(musicStore ? { musicStore } : {}),
         ...(process.env["COINPAY_WEBHOOK_SECRET"] ? { coinpayWebhookSecret: process.env["COINPAY_WEBHOOK_SECRET"] } : {}),
         ...(sharedTranslations ? { sharedTranslations } : {}),
         ...(translator ? { translator } : {}),

package/dist/station-cli.js

@@ -282,6 +282,8 @@ export async function station(argv) {
             }
             case "ai":
                 return await aiCommand(argv.slice(1), call, show, json);
+            case "label":
+                return await labelCommand(argv.slice(1), call, show);
             case "shares":
                 return await sharesCommand(argv.slice(1), call, show);
             case "lyrics":
@@ -438,6 +440,113 @@ async function aiCommand(argv, call, show, json) {
             return 2;
     }
 }
+/** `nixamp station label ...`: AI artists who put out an album a month (ai-label.ts). */
+async function labelCommand(argv, call, show) {
+    const [sub, key] = argv;
+    const when = (at) => at === -1 ? "never (off)" : at === 0 ? "now" : new Date(at).toISOString().slice(0, 10);
+    const describe = (one) => {
+        const albums = one["albums"] ?? [];
+        return [
+            `${String(one["name"])}  [${String(one["key"])}]  ${String(one["genre"])}${one["enabled"] ? "" : "  (off)"}`,
+            ...albums.map((album) => `  ${String(album["year"])}  ${String(album["title"])}  ${String(album["composed"])}/${String(album["songs"])} songs${album["doneAt"] ? "" : "  (recording)"}`),
+            `  next album ${when(Number(one["nextAlbumAt"] ?? -1))}`,
+            ...(one["lastError"] ? [`  problem    ${String(one["lastError"])}`] : []),
+        ].join("\n");
+    };
+    switch (sub) {
+        case undefined:
+        case "status":
+        case "list":
+            return show(await call("GET", "/api/v1/stations/label"), (body) => {
+                const settings = (body["settings"] ?? {});
+                const artists = body["artists"] ?? [];
+                const roster = body["roster"] ?? [];
+                return [
+                    `holder     ${String(settings["holder"])}${settings["enabled"] ? "" : "  (off)"}`,
+                    `files      ${String(body["root"])}/<genre>/<artist>/<year>-<album>/`,
+                    `composer   ${String(body["composer"] ?? "none")}; words by ${String(body["writer"] ?? "nobody (no model key)")}`,
+                    `this month ${String(body["secondsThisMonth"])} of ${Number(settings["monthlySeconds"]) === 0 ? "unlimited" : String(settings["monthlySeconds"])} s${body["busy"] ? `; recording ${String(body["busy"])}` : ""}`,
+                    `albums     ${String(settings["songsPerAlbum"])} songs of ${String(settings["songSeconds"])} s; ${String(settings["seedAlbums"])} to start, then one every ${String(settings["everyDays"])} days`,
+                    ...(body["waiting"] ? [`waiting    ${String(body["waiting"])}`] : []),
+                    "",
+                    ...(artists.length ? artists.map(describe) : ["Nobody signed yet. nixamp station label sign --roster"]),
+                    "",
+                    `roster     ${roster.map((one) => `${String(one["key"])}${one["signed"] ? " (signed)" : ""}`).join(", ")}`,
+                ].join("\n");
+            });
+        case "sign": {
+            const body = has(argv, "--roster") ? { roster: true } : {
+                ...(flag(argv, "--preset") ? { preset: flag(argv, "--preset") } : {}),
+                ...(flag(argv, "--name") ? { name: flag(argv, "--name") } : {}),
+                ...(flag(argv, "--genre") ? { genre: flag(argv, "--genre") } : {}),
+                ...(flag(argv, "--sound") ? { sound: flag(argv, "--sound") } : {}),
+                ...(flag(argv, "--voice") ? { voice: flag(argv, "--voice") } : {}),
+                ...(flag(argv, "--bio") ? { bio: flag(argv, "--bio") } : {}),
+                ...(flag(argv, "--themes") ? { themes: flag(argv, "--themes") } : {}),
+            };
+            return show(await call("POST", "/api/v1/stations/label/artists", body), (answer) => {
+                const signed = answer["artists"] ?? (answer["artist"] ? [answer["artist"]] : []);
+                return signed.length ? `Signed ${signed.map((one) => `${String(one["name"])} (${String(one["genre"])})`).join(", ")}. Their first albums are planned and recorded from here.` : "Everybody on the roster is already signed.";
+            });
+        }
+        case "album": {
+            if (!key) {
+                console.error("nixamp station label album needs the artist's key (nixamp station label)");
+                return 2;
+            }
+            return show(await call("POST", `/api/v1/stations/label/artists/${key}/album`, {}), (answer) => {
+                const album = answer["album"];
+                return `Planned "${String(album["title"])}" (${(album["songs"] ?? []).length} songs); recording now, a song at a time.`;
+            });
+        }
+        case "set": {
+            if (!key) {
+                console.error("nixamp station label set needs the artist's key");
+                return 2;
+            }
+            const body = {
+                ...(flag(argv, "--sound") ? { sound: flag(argv, "--sound") } : {}),
+                ...(flag(argv, "--voice") ? { voice: flag(argv, "--voice") } : {}),
+                ...(flag(argv, "--bio") ? { bio: flag(argv, "--bio") } : {}),
+                ...(flag(argv, "--themes") ? { themes: flag(argv, "--themes") } : {}),
+                ...(has(argv, "--off") ? { enabled: false } : has(argv, "--on") ? { enabled: true } : {}),
+            };
+            return show(await call("PATCH", `/api/v1/stations/label/artists/${key}`, body), (answer) => `${String(answer["artist"]["name"])} updated.`);
+        }
+        case "drop": {
+            if (!key) {
+                console.error("nixamp station label drop needs the artist's key");
+                return 2;
+            }
+            const files = has(argv, "--files");
+            return show(await call("DELETE", `/api/v1/stations/label/artists/${key}${files ? "?files=1" : ""}`), () => files ? "Dropped, with their music." : "Dropped. Their albums stay on the air; nothing new will be recorded.");
+        }
+        case "config": {
+            const number = (name) => (flag(argv, name) === undefined ? undefined : Number(flag(argv, name)));
+            const body = Object.fromEntries(Object.entries({
+                holder: flag(argv, "--holder"),
+                monthlySeconds: number("--budget"),
+                everyDays: number("--every-days"),
+                seedAlbums: number("--seed-albums"),
+                songsPerAlbum: number("--songs"),
+                songSeconds: number("--seconds"),
+                enabled: has(argv, "--off") ? false : has(argv, "--on") ? true : undefined,
+                publish: has(argv, "--unlisted") ? false : has(argv, "--public") ? true : undefined,
+            }).filter(([, value]) => value !== undefined));
+            return show(await call("POST", "/api/v1/stations/label", body), (answer) => {
+                const settings = answer["settings"];
+                return `Label: ${String(settings["holder"])}, ${String(settings["songsPerAlbum"])} songs of ${String(settings["songSeconds"])} s an album, every ${String(settings["everyDays"])} days, at most ${Number(settings["monthlySeconds"]) === 0 ? "unlimited" : `${String(settings["monthlySeconds"])} s`} a month${settings["enabled"] ? "" : " (off)"}.`;
+            });
+        }
+        case "run":
+            return show(await call("POST", "/api/v1/stations/label/run", {}), (body) => body["waiting"] ? `Nothing to record now: ${String(body["waiting"])}.` : "Recording whatever is due.");
+        case "resume":
+            return show(await call("POST", "/api/v1/stations/label", { resume: true }), () => "Recording again.");
+        default:
+            console.error(`nixamp station label: no command "${sub}".\n\n${USAGE}`);
+            return 2;
+    }
+}
 /** `nixamp station lyrics ...`: our own songs' words, published back to nichedb.dev. */
 async function lyricsCommand(argv, call, show, json) {
     const [sub, id] = argv;

package/dist/station-guide.d.ts

@@ -27,7 +27,7 @@ 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, ads?: GuideAds): string;
+export declare function renderGuide(entries: GuideEntry[], apiBase?: string, ads?: GuideAds, labelHref?: string): string;
 export declare const GUIDE_HTML: string;
 /**
  * The guide's policy. With crawlproof configured (guideAds below) its tracker