nixamp 0.48.1 → 0.50.1

package/src/music-store.ts

@@ -0,0 +1,333 @@
+/**
+ * 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 type { Db, Support } from "./support.ts";
+import { SupportError } from "./support.ts";
+
+export type Kind = "song" | "album" | "artist";
+
+/** In cents. */
+export const PRICES: Record<Kind, number> = { 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;
+
+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;
+}
+
+interface LabelSong { n: number; title: string }
+interface LabelAlbum { key: string; title: string; year: number; songs: LabelSong[] }
+interface LabelArtist { key: string; name: string; albums: LabelAlbum[] }
+interface LabelView { holder: string; genres: Array<{ genre: string; artists: LabelArtist[] }> }
+
+/** A server's public address as given: https, no path, no trailing slash. */
+export function serverBase(value: unknown): string {
+  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: string, text: string): string {
+  return createHmac("sha256", secret).update(text).digest("base64url");
+}
+
+/** `g1.<exp>.<kind>.<artist>.<album|->.<n>.<server, base64url>.<sig>` */
+export function makeGrant(secret: string, scope: Scope, exp: number): string {
+  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: string, grant: string, now = Date.now()): (Scope & { exp: number }) | null {
+  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] as Kind;
+  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: Pick<Scope, "kind" | "artist" | "album" | "n">, artist: string, album: string, n?: number): boolean {
+  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 {
+  private known = new Map<string, { scope: (Scope & { exp: number }) | null; until: number }>();
+
+  constructor(private readonly options: { site: string; secret?: string; fetcher?: typeof fetch; now?: () => number }) {}
+
+  async check(grant: string): Promise<(Scope & { exp: number }) | null> {
+    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() as { ok?: boolean; scope?: Scope & { exp: number } };
+      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: Record<string, unknown>): Purchase {
+  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"]) as 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 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 class MusicStore {
+  private schema: Promise<void> | null = null;
+
+  constructor(private readonly options: MusicStoreOptions) {}
+
+  private now(): number {
+    return this.options.now?.() ?? Date.now();
+  }
+
+  private ready(): Promise<void> {
+    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: unknown) => { this.schema = null; throw error; });
+    return this.schema;
+  }
+
+  /** A server's catalogue, as it publishes it at /api/v1/label. */
+  private async catalogue(server: string): Promise<LabelView> {
+    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() as LabelView;
+  }
+
+  /** What is for sale at this address, with its name and price; refused when there is no such thing. */
+  async describe(input: Record<string, unknown>): Promise<Scope & { title: string; artistName: string; amountCents: number; songs: number }> {
+    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"] ?? "") as 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: Record<string, unknown>, account: { id: string; email: string } | null): Promise<{ url: string; id: string; token: string }> {
+    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: string, token: string): string {
+    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: string, token: string): Promise<Purchase | null> {
+    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: string): Promise<{ settled: boolean; purchase?: string }> {
+    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: string): Promise<boolean> {
+    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). */
+  private async paid(id: string): Promise<Purchase | null> {
+    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: { id: string; email: string }): Promise<Purchase[]> {
+    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: Scope): string {
+    return makeGrant(this.options.secret, purchase, this.now() + GRANT_MS);
+  }
+
+  check(grant: string): (Scope & { exp: number }) | null {
+    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: Purchase): string {
+    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: Purchase): Record<string, unknown> {
+    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) } : {}),
+    };
+  }
+
+  private async mail(to: string, subject: string, lines: string[]): Promise<void> {
+    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 as Error).message}`);
+    }
+  }
+}

package/src/server.ts

@@ -78,6 +78,10 @@ import { ListenerStore } from "./library-user.ts";
 import { Importer } from "./handoff.ts";
 import { handleHandoffs } from "./handoff-routes.ts";
 import { handleAiRoutes, isPublicSharePath } from "./ai-routes.ts";
+import { AiLabel } from "./ai-label.ts";
+import { buyLink, handleLabelRoutes, isPublicLabelPath } from "./label-routes.ts";
+import { GrantVerifier, MusicStore } from "./music-store.ts";
+import { handleStoreRoutes, isStorePath } from "./store-routes.ts";
 import { AiRadio } from "./ai-radio.ts";
 import { ListenerShares } from "./listener-shares.ts";
 import { HolderStore, TagReader, factsFor } from "./track-facts.ts";
@@ -1746,6 +1750,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. */
@@ -1946,6 +1952,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;
@@ -2036,6 +2044,9 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     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: IncomingMessage, response: ServerResponse): Promise<void> {
     const url = new URL(request.url ?? "/", "http://localhost");
@@ -2591,6 +2602,15 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       }
       let event: ReturnType<typeof readCoinpayWebhook>;
       try { event = readCoinpayWebhook(JSON.parse(raw)); } catch { 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; }
       try {
         json(response, 200, await options.translationPasses.settle(event.paymentId));
@@ -2722,6 +2742,10 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       !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.
@@ -2905,7 +2929,8 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         ? 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] as GuideEntry[], options.stations!.publicBase?.() ?? "", ads);
+      const label = options.stations!.label;
+      const page = renderGuide([...rooms, ...entries, ...others] as GuideEntry[], 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",
@@ -3067,6 +3092,26 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       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
@@ -7279,10 +7324,27 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     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,
@@ -7348,7 +7410,18 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     try { stamp = String(Math.round(statSync(file).mtimeMs)); } catch { stamp = ""; }
     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({
+    // 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,
@@ -7357,7 +7430,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
       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.
@@ -7502,6 +7575,20 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     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 as unknown as import("./support.ts").Db,
+    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({
     ...(pool ? { db: pool } : {}),
@@ -8056,6 +8143,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(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/src/station-cli.ts

@@ -272,6 +272,8 @@ export async function station(argv: string[]): Promise<number> {
       }
       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":
@@ -412,6 +414,106 @@ async function aiCommand(argv: string[], call: Call, show: Show, json: boolean):
   }
 }
 
+/** `nixamp station label ...`: AI artists who put out an album a month (ai-label.ts). */
+async function labelCommand(argv: string[], call: Call, show: Show): Promise<number> {
+  const [sub, key] = argv;
+  const when = (at: number): string => at === -1 ? "never (off)" : at === 0 ? "now" : new Date(at).toISOString().slice(0, 10);
+  const describe = (one: Record<string, unknown>): string => {
+    const albums = (one["albums"] as Array<Record<string, unknown>> | undefined) ?? [];
+    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"] ?? {}) as Record<string, unknown>;
+        const artists = (body["artists"] as Record<string, unknown>[] | undefined) ?? [];
+        const roster = (body["roster"] as Array<Record<string, unknown>> | undefined) ?? [];
+        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"] as Array<Record<string, unknown>> | undefined) ?? (answer["artist"] ? [answer["artist"] as Record<string, unknown>] : []);
+        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"] as Record<string, unknown>;
+        return `Planned "${String(album["title"])}" (${((album["songs"] as unknown[]) ?? []).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"] as Record<string, unknown>)["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: string): number | undefined => (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"] as Record<string, unknown>;
+        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: string[], call: Call, show: Show, json: boolean): Promise<number> {
   const [sub, id] = argv;