nixamp 0.49.0 → 0.50.1

package/dist/ai-label.d.ts

@@ -186,6 +186,35 @@ export declare class AiLabel {
         path: string;
         type: string;
     } | null;
+    /** The label song at this path, for the now-playing card's Download buttons. */
+    songAt(file: string): {
+        artist: string;
+        album: string;
+        n: number;
+        title: string;
+        artistName: string;
+        albumTitle: string;
+    } | null;
+    /** A released song's MP3, when this grant's scope covers it. */
+    songFile(artistKey: string, albumKey: string, n: number): string;
+    /**
+     * What a purchase's zip holds: every released song in scope with its words,
+     * and each album's cover and album.json, under <artist>/<year>-<album>/.
+     * Null when there is nothing (or no such artist).
+     */
+    zipFor(scope: {
+        kind: "song" | "album" | "artist";
+        artist: string;
+        album: string;
+        n: number;
+    }): {
+        name: string;
+        entries: Array<{
+            name: string;
+            path?: string;
+            bytes?: Uint8Array;
+        }>;
+    } | null;
     private require;
 }
 export interface PublicArtist {

package/dist/ai-label.js

@@ -132,7 +132,7 @@ const PLAN_SYSTEM = [
 const LYRICS_SYSTEM = [
     "You write original English song lyrics for an AI singer. Never quote or imitate an existing song and never name a real artist.",
     "Put each section tag on its own line: [Intro], [Verse 1], [Pre-Chorus], [Chorus], [Verse 2], [Bridge], [Outro].",
-    "Use two verses, a chorus sung two or three times and a bridge; vivid, specific, singable lines that rhyme where it sounds natural.",
+    "Use two verses of four lines, a four-line chorus sung two or three times, a pre-chorus of two lines and a bridge of two to four lines; vivid, specific, singable lines that rhyme where it sounds natural. Never just one line under a section.",
     "Only the words that are sung, no stage directions or notes. Answer as JSON: {\"lyrics\": \"the lyrics, lines separated by \\n\"}.",
 ].join(" ");
 export async function planAlbum(artist, songs, ask = askJson) {
@@ -716,6 +716,55 @@ export class AiLabel {
             return null;
         return match[2] === "mp3" ? { path: song.file, type: "audio/mpeg" } : { path: song.lyricsFile, type: "text/plain; charset=utf-8" };
     }
+    /** The label song at this path, for the now-playing card's Download buttons. */
+    songAt(file) {
+        for (const artist of this.artists.values()) {
+            for (const album of artist.albums) {
+                const song = album.songs.find((one) => one.file === file);
+                if (song)
+                    return { artist: artist.key, album: album.key, n: song.n, title: song.title, artistName: artist.name, albumTitle: album.title };
+            }
+        }
+        return null;
+    }
+    /** A released song's MP3, when this grant's scope covers it. */
+    songFile(artistKey, albumKey, n) {
+        return this.artists.get(artistKey)?.albums.find((one) => one.key === albumKey)?.songs.find((one) => one.n === n && one.file)?.file ?? "";
+    }
+    /**
+     * What a purchase's zip holds: every released song in scope with its words,
+     * and each album's cover and album.json, under <artist>/<year>-<album>/.
+     * Null when there is nothing (or no such artist).
+     */
+    zipFor(scope) {
+        const artist = this.artists.get(scope.artist);
+        if (!artist)
+            return null;
+        const albums = artist.albums.filter((one) => scope.kind === "artist" || one.key === scope.album);
+        const entries = [];
+        const top = fileName(artist.name);
+        for (const album of albums) {
+            const songs = album.songs.filter((one) => one.file && (scope.kind !== "song" || one.n === scope.n));
+            if (songs.length === 0)
+                continue;
+            const folder = `${top}/${album.year}-${fileName(album.title)}`;
+            for (const song of songs) {
+                entries.push({ name: `${folder}/${songBase(song)}.mp3`, path: song.file });
+                entries.push({ name: `${folder}/${songBase(song)}.lyrics.txt`, bytes: Buffer.from(`${song.lyrics}\n`) });
+            }
+            if (album.cover)
+                entries.push({ name: `${folder}/cover.jpg`, path: album.cover });
+            entries.push({ name: `${folder}/album.json`, bytes: Buffer.from(`${JSON.stringify({
+                    artist: artist.name, genre: artist.genre, album: album.title, year: album.year, concept: album.concept,
+                    label: this.settings.holder, copyright: `℗ ${album.year} ${this.settings.holder}`, madeWithAi: true,
+                    songs: songs.map((one) => ({ n: one.n, title: one.title, seconds: one.seconds, file: `${songBase(one)}.mp3`, lyrics: `${songBase(one)}.lyrics.txt` })),
+                }, null, 2)}\n`) });
+        }
+        if (entries.length === 0)
+            return null;
+        const what = scope.kind === "artist" ? "Discography" : scope.kind === "album" ? albums[0].title : this.songFile(scope.artist, scope.album, scope.n) ? albums[0].songs.find((one) => one.n === scope.n).title : "Song";
+        return { name: `${fileName(artist.name)} - ${fileName(what)}.zip`, entries };
+    }
     require(key) {
         const artist = this.artists.get(key);
         if (!artist)

package/dist/label-routes.d.ts

@@ -1,15 +1,28 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { type AiLabel } from "./ai-label.ts";
-/** Whether this path is the label's public face. */
+import { type GrantVerifier } from "./music-store.ts";
+/** Whether this path is the label's public face (an MP3 or the zip still asks for its grant). */
 export declare function isPublicLabelPath(path: string): boolean;
+/** nixamp.com's page that sells this: a song, an album or everything by the artist. */
+export declare function buyLink(site: string, server: string, kind: "song" | "album" | "artist", artist: string, album?: string, n?: number): string;
 export interface LabelRoutesContext {
     label: AiLabel;
     canControl: boolean;
+    /** Checks a store grant with nixamp.com; without it nothing is sold or handed out. */
+    grants?: GrantVerifier;
+    /** nixamp.com, where the store is, and this server's public address (for Buy links). */
+    site?: string;
+    publicBase?: string;
     json: (response: ServerResponse, status: number, body: unknown) => void;
     readBody: (request: IncomingMessage) => Promise<string>;
 }
 /** Answers the paths above and the owner's; false when the path is neither. */
 export declare function handleLabelRoutes(request: IncomingMessage, response: ServerResponse, path: string, ctx: LabelRoutesContext): Promise<boolean>;
 export declare const LABEL_CSP: string;
+type Shop = {
+    site: string;
+    server: string;
+} | undefined;
 /** The label's catalogue as a page: no script, plays in any browser. */
-export declare function renderLabel(view: ReturnType<AiLabel["publicView"]>): string;
+export declare function renderLabel(view: ReturnType<AiLabel["publicView"]>, shop?: Shop): string;
+export {};

package/dist/label-routes.js

@@ -9,13 +9,21 @@
 import { createHash } from "node:crypto";
 import { createReadStream, statSync } from "node:fs";
 import { ROSTER } from "./ai-label.js";
+import { covers, PRICES } from "./music-store.js";
+import { writeZip, zipSize } from "./zip-stream.js";
 import { StationError } from "./stations.js";
 // Listening is free on the live stations (with their breaks); the songs as
-// files are sold, so only the words and the cover are public here.
-const FILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/([a-f0-9]{8})\/(\d{1,3}\.txt|cover\.jpg)$/;
-/** Whether this path is the label's public face. */
+// files are sold, so only the words and the cover are public here, and an
+// MP3 or a zip needs a grant from nixamp.com's store (music-store.ts).
+const FILE = /^\/api\/v1\/label\/([a-f0-9]{10})\/([a-f0-9]{8})\/(\d{1,3}\.(?:txt|mp3)|cover\.jpg)$/;
+/** Whether this path is the label's public face (an MP3 or the zip still asks for its grant). */
 export function isPublicLabelPath(path) {
-    return path === "/label" || path === "/api/v1/label" || FILE.test(path);
+    return path === "/label" || path === "/api/v1/label" || path === "/api/v1/label/zip" || FILE.test(path);
+}
+/** nixamp.com's page that sells this: a song, an album or everything by the artist. */
+export function buyLink(site, server, kind, artist, album = "", n = 0) {
+    const query = new URLSearchParams({ server, kind, artist, ...(kind !== "artist" ? { album } : {}), ...(kind === "song" ? { n: String(n) } : {}) });
+    return `${site}/buy?${query.toString()}`;
 }
 async function jsonBody(ctx, request) {
     const raw = await ctx.readBody(request);
@@ -79,7 +87,8 @@ export async function handleLabelRoutes(request, response, path, ctx) {
                 return true;
             }
             if (path === "/label") {
-                const page = renderLabel(label.publicView());
+                const shop = ctx.grants && ctx.site && /^https:\/\//.test(ctx.publicBase ?? "") ? { site: ctx.site, server: ctx.publicBase } : undefined;
+                const page = renderLabel(label.publicView(), shop);
                 response.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-security-policy": LABEL_CSP, "cache-control": "public, max-age=300" });
                 response.end(method === "HEAD" ? undefined : page);
                 return true;
@@ -88,7 +97,45 @@ export async function handleLabelRoutes(request, response, path, ctx) {
                 ctx.json(response, 200, label.publicView());
                 return true;
             }
+            const url = new URL(request.url ?? "/", "http://x");
+            const grant = url.searchParams.get("grant") ?? "";
+            if (path === "/api/v1/label/zip") {
+                const scope = ctx.grants ? await ctx.grants.check(grant) : null;
+                if (!scope) {
+                    ctx.json(response, 403, { error: "that download link has expired or is not one of ours: open your purchase again for a fresh one", code: "bad_grant" });
+                    return true;
+                }
+                const zip = label.zipFor(scope);
+                if (!zip) {
+                    ctx.json(response, 404, { error: "nothing to download yet", code: "not_found" });
+                    return true;
+                }
+                response.writeHead(200, {
+                    "content-type": "application/zip",
+                    "content-length": String(zipSize(zip.entries)),
+                    "content-disposition": `attachment; filename*=UTF-8''${encodeURIComponent(zip.name)}`,
+                    "cache-control": "private, no-store",
+                });
+                if (method === "HEAD") {
+                    response.end();
+                    return true;
+                }
+                await writeZip(response, zip.entries).catch(() => response.destroy());
+                response.end();
+                return true;
+            }
             const [, artist, album, what] = FILE.exec(path);
+            if (what.endsWith(".mp3")) {
+                const scope = ctx.grants && grant ? await ctx.grants.check(grant) : null;
+                const n = Number(what.split(".")[0]);
+                const file = scope && covers(scope, artist, album, n) ? label.songFile(artist, album, n) : "";
+                if (!file) {
+                    ctx.json(response, 403, { error: "songs as files are for the people who bought them; listening on the live stations is free", code: "not_bought" });
+                    return true;
+                }
+                sendFile(request, response, file, "audio/mpeg", file.split("/").pop() ?? "");
+                return true;
+            }
             const found = label.publicFile(artist, album, what);
             if (!found) {
                 ctx.json(response, 404, { error: "no such file on the label", code: "not_found" });
@@ -204,6 +251,7 @@ audio{width:100%;max-width:360px;height:36px}
 details{margin-top:4px}summary{cursor:pointer;color:var(--muted);font-size:.9rem}
 pre.lyrics{white-space:pre-wrap;font:inherit;font-size:.95rem;margin:8px 0 0;padding:12px;border-radius:8px;background:var(--bg)}
 .dl{font-size:.85rem}.soon{color:var(--muted);font-size:.85rem}
+a.buy{display:inline-block;font-weight:700;text-decoration:none;border:1px solid var(--accent);border-radius:999px;padding:2px 10px}
 footer{margin-top:48px;color:var(--muted);font-size:.85rem}footer a{color:inherit}
 `;
 function hash(text) {
@@ -213,24 +261,35 @@ export const LABEL_CSP = [
     "default-src 'none'", `style-src ${hash(STYLE)}`, "img-src 'self'",
     "base-uri 'none'", "form-action 'none'", "frame-ancestors 'none'",
 ].join("; ");
-function renderAlbum(artist, album) {
+function price(cents) {
+    return cents < 100 ? `${cents}¢` : `$${(cents / 100).toFixed(cents % 100 ? 2 : 0)}`;
+}
+function buy(shop, kind, artist, album = "", n = 0, what = "") {
+    if (!shop)
+        return "";
+    return `<a class="buy" href="${escape(buyLink(shop.site, shop.server, kind, artist, album, n))}">Download ${what || kind} · ${price(PRICES[kind])}</a>`;
+}
+function renderAlbum(artist, album, shop) {
     const base = `/api/v1/label/${artist.key}/${album.key}`;
     const cover = album.cover ? `<img class="cover" src="${base}/cover.jpg" alt="Cover of ${escape(album.title)}" width="160" height="160" loading="lazy">` : `<div class="blank" aria-hidden="true"></div>`;
     const songs = album.songs.map((song) => `<li><div class="song"><span class="n">${song.n}.</span><span class="t">${escape(song.title)}</span><span class="d">${minutes(song.seconds)}</span></div>`
         + `<details><summary>Lyrics</summary><pre class="lyrics">${escape(song.lyrics)}</pre></details>`
-        + `<div class="dl"><a href="${base}/${song.n}.txt">lyrics.txt</a></div></li>`).join("");
+        + `<div class="dl"><a href="${base}/${song.n}.txt">lyrics.txt</a>${shop ? ` · ${buy(shop, "song", artist.key, album.key, song.n, "MP3")}` : ""}</div></li>`).join("");
     return `<div class="album">${cover}<div><h4>${escape(album.title)} <span class="d">(${album.year})</span></h4>`
         + `${album.concept ? `<p class="concept">${escape(album.concept)}</p>` : ""}`
         + `${album.complete ? "" : `<p class="soon">Still being recorded: new songs land here as they are finished.</p>`}`
+        + `${shop ? `<p>${buy(shop, "album", artist.key, album.key, 0, "the album, MP3s with art and lyrics")}</p>` : ""}`
         + `<ol class="songs">${songs}</ol></div></div>`;
 }
 /** The label's catalogue as a page: no script, plays in any browser. */
-export function renderLabel(view) {
+export function renderLabel(view, shop) {
     const label = view.holder.replace(/,?\s+(inc|llc|ltd|gmbh|co)\.?$/i, "");
     const nav = view.genres.length > 1 ? `<nav class="genres" aria-label="Genres">${view.genres.map((one) => `<a href="#${escape(one.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(one.genre)}</a>`).join("")}</nav>` : "";
     const sections = view.genres.map((genre) => `<section class="genre" id="${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}" aria-labelledby="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">`
         + `<h2 id="g-${escape(genre.genre.toLowerCase().replace(/[^a-z0-9]+/g, "-"))}">${escape(genre.genre)}${genre.station ? ` <a href="/watch/${escape(genre.station)}">Listen live, free →</a>` : ""}</h2>`
-        + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}${artist.albums.map((album) => renderAlbum(artist, album)).join("")}</article>`).join("")
+        + genre.artists.map((artist) => `<article class="artist"><h3>${escape(artist.name)}</h3>${artist.bio ? `<p class="bio">${escape(artist.bio)}</p>` : ""}`
+            + `${shop ? `<p>${buy(shop, "artist", artist.key, "", 0, "everything by them")}</p>` : ""}`
+            + `${artist.albums.map((album) => renderAlbum(artist, album, shop)).join("")}</article>`).join("")
         + `</section>`).join("");
     return `<!doctype html>
 <html lang="en">

package/dist/music-store.d.ts

@@ -0,0 +1,121 @@
+import type { Db, Support } from "./support.ts";
+export type Kind = "song" | "album" | "artist";
+/** In cents. */
+export declare const PRICES: Record<Kind, number>;
+export interface Scope {
+    server: string;
+    kind: Kind;
+    artist: string;
+    album: string;
+    n: number;
+}
+export interface Purchase extends Scope {
+    id: string;
+    token: string;
+    email: string;
+    userId: string;
+    title: string;
+    artistName: string;
+    amountCents: number;
+    coin: string;
+    paymentId: string;
+    status: "pending" | "paid";
+    createdAt: number;
+    paidAt: number;
+}
+/** A server's public address as given: https, no path, no trailing slash. */
+export declare function serverBase(value: unknown): string;
+/** `g1.<exp>.<kind>.<artist>.<album|->.<n>.<server, base64url>.<sig>` */
+export declare function makeGrant(secret: string, scope: Scope, exp: number): string;
+export declare function readGrant(secret: string, grant: string, now?: number): (Scope & {
+    exp: number;
+}) | null;
+/** Whether a grant for `scope` covers this file of the catalogue. */
+export declare function covers(scope: Pick<Scope, "kind" | "artist" | "album" | "n">, artist: string, album: string, n?: number): boolean;
+/**
+ * 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 declare class GrantVerifier {
+    private readonly options;
+    private known;
+    constructor(options: {
+        site: string;
+        secret?: string;
+        fetcher?: typeof fetch;
+        now?: () => number;
+    });
+    check(grant: string): Promise<(Scope & {
+        exp: number;
+    }) | null>;
+}
+export interface MusicStoreOptions {
+    db: Db;
+    support: Support;
+    /** Resend; null leaves the receipt unsent (and says so in the log). */
+    mail: {
+        apiKey: string;
+        from: string;
+    } | null;
+    site: string;
+    /** Signs the grants; derived from NIXAMP_JWT_SECRET. */
+    secret: string;
+    /** The servers whose catalogues may be sold here (the directory and the guide's peers). */
+    servers: () => string[];
+    fetcher?: typeof fetch;
+    now?: () => number;
+    log?: (line: string) => void;
+}
+export declare class MusicStore {
+    private readonly options;
+    private schema;
+    constructor(options: MusicStoreOptions);
+    private now;
+    private ready;
+    /** A server's catalogue, as it publishes it at /api/v1/label. */
+    private catalogue;
+    /** What is for sale at this address, with its name and price; refused when there is no such thing. */
+    describe(input: Record<string, unknown>): Promise<Scope & {
+        title: string;
+        artistName: string;
+        amountCents: number;
+        songs: number;
+    }>;
+    /** A purchase waiting for its payment, and where to pay. Signed in, it is the account's too. */
+    checkout(input: Record<string, unknown>, account: {
+        id: string;
+        email: string;
+    } | null): Promise<{
+        url: string;
+        id: string;
+        token: string;
+    }>;
+    /** The purchase's own page, which is also the receipt link. */
+    link(id: string, token: string): string;
+    /** A purchase by its link; a pending one asks CoinPay whether it has been paid since. */
+    get(id: string, token: string): Promise<Purchase | null>;
+    /** CoinPay's webhook: a payment of ours that is now paid. False when it is not a music purchase. */
+    settle(paymentId: string): Promise<{
+        settled: boolean;
+        purchase?: string;
+    }>;
+    /** Whether CoinPay's webhook is about one of ours. */
+    owns(paymentId: string): Promise<boolean>;
+    /** Marks it paid once (the first to get there sends the receipt). */
+    private paid;
+    /** Every paid purchase of this account: made signed in, or to its email. */
+    forAccount(account: {
+        id: string;
+        email: string;
+    }): Promise<Purchase[]>;
+    grant(purchase: Scope): string;
+    check(grant: string): (Scope & {
+        exp: number;
+    }) | null;
+    /** Where the zip of a purchase is made: on the server that holds the music. */
+    zipUrl(purchase: Purchase): string;
+    /** What anybody with the purchase's link (or the account) is shown. */
+    view(purchase: Purchase): Record<string, unknown>;
+    private mail;
+}