nixamp 0.3.0 → 0.4.0

package/dist/server.js

@@ -22,11 +22,17 @@ import { RtmpListeners } from "./rtmp-in.js";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.js";
 import { needsAdmin, Owner } from "./owner.js";
 import { readSession } from "./session.js";
-import { Directory, parseAnnouncement } from "./directory.js";
+import { Directory, ENDED_TTL_MS, parseAnnouncement } from "./directory.js";
+import { PartyLine, telnyxSms } from "./partyline.js";
+import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.js";
+import pg from "pg";
+import { Follows, phoneFrom } from "./follows.js";
+import { Durable } from "./durable.js";
+import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
-import { isRemote } from "./sources.js";
-import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, newKey, portCommands, reachableAddresses, scopeOf, shareLink, } from "./share.js";
+import { isRemote, playsInBrowser } from "./sources.js";
+import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, newKey, portCommands, reachableAddresses, scopeOf, shareLink, audioLink, } from "./share.js";
 import { extname, join, normalize, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { detectTools, peaks, RATE, Stream, toMono, } from "./audio.js";
@@ -533,6 +539,202 @@ export function createHandler(engine, options) {
             response.end();
             return;
         }
+        // The page explaining the reminder texts. Public for the same reason the
+        // webhook is: the reader is a carrier reviewing the number, or somebody
+        // who just got a message and wants it to stop. Neither has a share link.
+        if (path === OPT_IN_PATH && options.partyLine) {
+            const body = optInPage();
+            response.writeHead(200, {
+                ...CORS,
+                "content-type": "text/html; charset=utf-8",
+                "content-length": Buffer.byteLength(body),
+            });
+            response.end(request.method === "HEAD" ? undefined : body);
+            return;
+        }
+        // --- following a broadcaster ------------------------------------------
+        //
+        // Behind the sign-in rather than the share key: a follow belongs to an
+        // account, and an account is the only thing that makes "notify me on my
+        // other device" mean anything.
+        if (path.startsWith("/api/v1/follows") && options.follows && options.accounts) {
+            const me = await options.accounts.whoIs(tokenFrom(request.headers));
+            if (me === null) {
+                json(response, 401, { error: "sign in to follow" });
+                return;
+            }
+            const follows = options.follows;
+            if (path === "/api/v1/follows" && request.method === "GET") {
+                const ids = await follows.following(me.id);
+                // An id is not a name. The directory is the only thing that knows what
+                // an account calls itself, from the last stream it announced -- which
+                // is empty for somebody who has never streamed, and the caller decides
+                // what to show for that rather than being handed a blank.
+                json(response, 200, {
+                    following: ids.map((id) => ({
+                        id,
+                        name: options.directory?.nameOf(id) ?? "",
+                        live: options.directory?.isLive(id) ?? false,
+                    })),
+                });
+                return;
+            }
+            const streamer = path.slice("/api/v1/follows/".length);
+            if (!path.startsWith("/api/v1/follows/") || !streamer) {
+                json(response, 404, { error: "no such endpoint" });
+                return;
+            }
+            if (request.method === "PUT" || request.method === "POST") {
+                const added = await follows.follow(me.id, decodeURIComponent(streamer));
+                // Following yourself is refused rather than silently stored: you do
+                // not need telling that you went live.
+                json(response, added ? 200 : 422, added
+                    ? { following: true, followers: await follows.followerCount(decodeURIComponent(streamer)) }
+                    : { error: "you cannot follow yourself" });
+                return;
+            }
+            if (request.method === "DELETE") {
+                await follows.unfollow(me.id, decodeURIComponent(streamer));
+                json(response, 200, { following: false });
+                return;
+            }
+            if (request.method === "GET") {
+                json(response, 200, { following: await follows.isFollowing(me.id, decodeURIComponent(streamer)) });
+                return;
+            }
+            json(response, 405, { error: "PUT, DELETE or GET" });
+            return;
+        }
+        // --- where to reach a follower ----------------------------------------
+        if (path.startsWith("/api/v1/notify") && options.follows && options.accounts) {
+            // The key is public by design: it is what a browser needs before it can
+            // ask permission, and it is useless without the private half.
+            if (path === "/api/v1/notify/key" && request.method === "GET") {
+                json(response, 200, { publicKey: options.vapidPublicKey ?? "" });
+                return;
+            }
+            const me = await options.accounts.whoIs(tokenFrom(request.headers));
+            if (me === null) {
+                json(response, 401, { error: "sign in first" });
+                return;
+            }
+            const follows = options.follows;
+            if (path === "/api/v1/notify/prefs") {
+                if (request.method === "GET") {
+                    json(response, 200, await follows.prefs(me.id));
+                    return;
+                }
+                if (request.method !== "PUT" && request.method !== "POST") {
+                    json(response, 405, { error: "GET or PUT" });
+                    return;
+                }
+                let body;
+                try {
+                    body = JSON.parse(await readBody(request));
+                }
+                catch {
+                    json(response, 400, { error: "bad JSON" });
+                    return;
+                }
+                // A number we cannot dial is worse than no number: it is a text that
+                // silently goes nowhere for as long as nobody checks.
+                if (body["phone"] !== undefined && body["phone"] !== "" && !phoneFrom(body["phone"])) {
+                    json(response, 422, { error: "that does not look like a phone number" });
+                    return;
+                }
+                await follows.setPrefs(me.id, {
+                    ...(body["phone"] === undefined ? {} : { phone: String(body["phone"]) }),
+                    ...(typeof body["wantsEmail"] === "boolean" ? { wantsEmail: body["wantsEmail"] } : {}),
+                    ...(typeof body["wantsSms"] === "boolean" ? { wantsSms: body["wantsSms"] } : {}),
+                    ...(typeof body["wantsWeb"] === "boolean" ? { wantsWeb: body["wantsWeb"] } : {}),
+                });
+                json(response, 200, await follows.prefs(me.id));
+                return;
+            }
+            if (path === "/api/v1/notify/subscribe") {
+                if (request.method === "DELETE") {
+                    const endpoint = url.searchParams.get("endpoint") ?? "";
+                    await follows.removePush(endpoint);
+                    json(response, 200, { ok: true });
+                    return;
+                }
+                if (request.method !== "POST" && request.method !== "PUT") {
+                    json(response, 405, { error: "POST or DELETE" });
+                    return;
+                }
+                let body;
+                try {
+                    body = JSON.parse(await readBody(request));
+                }
+                catch {
+                    json(response, 400, { error: "bad JSON" });
+                    return;
+                }
+                const endpoint = typeof body.endpoint === "string" ? body.endpoint : "";
+                const p256dh = typeof body.keys?.p256dh === "string" ? body.keys.p256dh : "";
+                const auth = typeof body.keys?.auth === "string" ? body.keys.auth : "";
+                if (!endpoint || !p256dh || !auth) {
+                    json(response, 422, { error: "a subscription needs an endpoint and both keys" });
+                    return;
+                }
+                await follows.addPush(me.id, { endpoint, p256dh, auth });
+                json(response, 200, { ok: true });
+                return;
+            }
+            json(response, 404, { error: "no such endpoint" });
+            return;
+        }
+        // --- the party line ---------------------------------------------------
+        //
+        // Ahead of the share-key check because the caller is a telephone. Telnyx
+        // has no cookie and no link; what it has is an ed25519 signature over the
+        // body, which is a stronger claim than a key in a URL anyway.
+        if (path.startsWith("/api/v1/partyline/") && options.partyLine) {
+            const partyLine = options.partyLine;
+            if (path === "/api/v1/partyline/rooms") {
+                json(response, 200, { rooms: partyLine.list() });
+                return;
+            }
+            if (path !== "/api/v1/partyline/webhook") {
+                json(response, 404, { error: "no such endpoint" });
+                return;
+            }
+            if (request.method !== "POST") {
+                json(response, 405, { error: "POST only" });
+                return;
+            }
+            // The bytes as they arrived. Parsing first and reserialising would
+            // change the whitespace the signature was computed over.
+            let raw;
+            try {
+                raw = await readBody(request);
+            }
+            catch {
+                json(response, 413, { error: "body too large" });
+                return;
+            }
+            const signature = request.headers["telnyx-signature-ed25519"];
+            const timestamp = request.headers["telnyx-timestamp"];
+            const ok = partyLine.verify(raw, typeof signature === "string" ? signature : undefined, typeof timestamp === "string" ? timestamp : undefined);
+            if (!ok) {
+                json(response, 401, { error: "bad signature" });
+                return;
+            }
+            let event;
+            try {
+                event = JSON.parse(raw);
+            }
+            catch {
+                json(response, 400, { error: "bad JSON" });
+                return;
+            }
+            // Answer first, act second. Telnyx retries anything it does not hear
+            // back about quickly, and a retried call.answered would ask the caller
+            // which room they wanted twice.
+            json(response, 200, { ok: true });
+            void partyLine.handle(event.data ?? {}).catch(() => { });
+            return;
+        }
         // /api/health answers unauthenticated on purpose: it is how you check the
         // port is open from another device before wondering whether the link is
         // wrong, and it says nothing about the library.
@@ -615,16 +817,53 @@ export function createHandler(engine, options) {
             response.end(JSON.stringify({ account: result.account, token: result.token }));
             return;
         }
-        // The directory is public in both directions: anyone may read the list,
-        // and anyone running a nixamp may add themselves to it. It is answered
-        // before the key check, because a visitor to nixamp.com has no key and is
-        // exactly who it is for.
+        // The directory is public to read and answered before the key check,
+        // because a visitor to nixamp.com has no key and is exactly who it is for.
+        //
+        // Announcing is not public any more. A listing now carries a phone number
+        // people dial and minutes we pay for, so it has to be attributable to
+        // somebody: broadcasters register, and a caller just dials. Reading stays
+        // open to everyone -- the whole point is a directory a stranger can browse.
         if (path === "/api/directory" && options.directory) {
             if (request.method === "GET") {
-                json(response, 200, { streams: options.directory.list(), now: Date.now() });
+                // Each stream carries its call-in code and how many people are on the
+                // phone for it. The code is published on purpose: it is a public
+                // call-in line, and a listing you cannot dial is a listing of nothing.
+                const onThePhone = options.partyLine;
+                const streams = options.directory.list().map((stream) => ({
+                    ...stream,
+                    callers: onThePhone ? onThePhone.listenersOn(stream.code) : 0,
+                }));
+                // Recently ended too, because following exists to hear about
+                // broadcasts you would otherwise miss -- and a list of only what is on
+                // can only be used to follow somebody during a broadcast you did not
+                // miss. No url and no code: there is nothing to listen to.
+                const recent = options.directory.recentlyEnded().map((stream) => ({
+                    name: stream.name,
+                    ownerId: stream.ownerId,
+                    nowPlaying: stream.nowPlaying,
+                    endedAt: stream.endedAt,
+                }));
+                json(response, 200, { streams, recent, callIn: CALL_IN_NUMBER, now: Date.now() });
                 return;
             }
             if (request.method === "POST") {
+                // Only where there are accounts to check against. An instance with no
+                // Accounts is somebody's laptop, which has no registration to demand.
+                let ownerId = "";
+                if (options.accounts) {
+                    const who = await options.accounts.whoIs(tokenFrom(request.headers));
+                    if (who === null) {
+                        json(response, 401, {
+                            error: "sign in to list a stream: nixamp login, then nixamp serve --directory",
+                        });
+                        return;
+                    }
+                    // From the token, never the body. A stream that could name its own
+                    // owner could name somebody else's, and their followers would be
+                    // told about a broadcast that person is not making.
+                    ownerId = who.id;
+                }
                 let announcement;
                 try {
                     announcement = parseAnnouncement(JSON.parse(await readBody(request)));
@@ -637,7 +876,16 @@ export function createHandler(engine, options) {
                     json(response, 422, { error: "a listing needs a name and a URL a browser can reach" });
                     return;
                 }
-                json(response, 200, options.directory.announce(announcement));
+                const listing = options.directory.announce(announcement, ownerId);
+                // A stream reappearing is the event somebody asked to be told about.
+                // Answered first and texted after, because the publisher's heartbeat
+                // should not wait on an SMS gateway.
+                json(response, 200, listing);
+                if (options.partyLine) {
+                    void options.partyLine
+                        .wentLive({ code: listing.code, name: listing.name, nowPlaying: listing.nowPlaying })
+                        .catch(() => { });
+                }
                 return;
             }
             if (request.method === "DELETE") {
@@ -981,13 +1229,36 @@ export function createHandler(engine, options) {
                 return;
             }
             watch(request, response, "media", engine.snapshot().tracks[index]?.title ?? file);
-            sendFile(request, response, file);
+            // A browser asks for every track here, and a matroska or an avi handed
+            // to it raw is bytes it cannot play. Seeking is what this route is for
+            // and transcoding gives it up, but an unseekable film beats a silent
+            // one -- and the seekable formats are untouched.
+            if (playsInBrowser(file))
+                sendFile(request, response, file);
+            else
+                transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
             return;
         }
         // Whatever the source is, this comes back as MP3 a browser will play:
         // a flac, a wma, a URL, an HLS stream. ffmpeg reads them all and we hand
         // the bytes on as they arrive, so a live stream starts immediately rather
         // than after it ends, which for a live stream is never.
+        // One address that keeps playing, for a listener that cannot ask for the
+        // next track: the phone line hands exactly this to Telnyx.
+        if (path === "/api/live") {
+            if (!options.media) {
+                json(response, 403, { error: "media streaming is off" });
+                return;
+            }
+            const current = engine.snapshot();
+            if (current.tracks.length === 0) {
+                json(response, 404, { error: "nothing is playing" });
+                return;
+            }
+            watch(request, response, "stream", current.tracks[current.index]?.title ?? "live");
+            liveAudio(request, response, engine, options.ffmpeg ?? ["ffmpeg"]);
+            return;
+        }
         if (path.startsWith("/api/stream/")) {
             const index = Number(path.slice("/api/stream/".length));
             const source = Number.isInteger(index) ? engine.trackPath(index) : undefined;
@@ -1038,6 +1309,127 @@ function readIfPossible(path) {
         return null;
     }
 }
+/** How long to wait before looking again when the player has not moved on. */
+const LIVE_GAP_MS = 500;
+/** How long to wait when there is nothing to play at all yet. */
+const LIVE_IDLE_MS = 2000;
+/**
+ * Whatever is playing, as one endless MP3.
+ *
+ * /api/stream/N is one track: it needs an index, and it stops at the end of
+ * the song. That is right for a browser, which knows what is playing and can
+ * ask for the next one. It is wrong for everything that cannot -- a telephone
+ * call, `curl | mpv`, anything handed a single address and expected to keep
+ * hearing sound. Those need one URL that never ends and never needs asking
+ * again, which is what a listener means by "the stream".
+ *
+ * So this follows the player rather than an index: transcode what is playing,
+ * and when that track ends look at what is playing now and keep writing into
+ * the same response. The listener sees one continuous audio/mpeg body.
+ *
+ * Read at native rate (-re), unlike /api/stream/N which is free to run ahead
+ * into a browser's buffer. Here running ahead would finish the song in two
+ * seconds and then sit waiting for the player to catch up, so the thing that
+ * decides what plays next would be minutes behind what the listener hears.
+ */
+function liveAudio(request, response, engine, ffmpeg) {
+    const [command, ...prefix] = ffmpeg;
+    let child = null;
+    let waiting = null;
+    let closed = false;
+    let started = false;
+    let playing = -1;
+    // Held back until the first byte, for the reason transcode() holds it back:
+    // a 200 with nothing behind it is indistinguishable from silence.
+    const begin = () => {
+        if (started || closed)
+            return;
+        started = true;
+        response.writeHead(200, {
+            ...CORS,
+            "content-type": "audio/mpeg",
+            "cache-control": "no-store",
+            "transfer-encoding": "chunked",
+        });
+    };
+    const later = (ms, run) => {
+        if (waiting)
+            clearTimeout(waiting);
+        waiting = setTimeout(run, ms);
+        waiting.unref?.();
+    };
+    const stop = () => {
+        if (closed)
+            return;
+        closed = true;
+        if (waiting)
+            clearTimeout(waiting);
+        waiting = null;
+        unsubscribe();
+        child?.kill("SIGKILL");
+        child = null;
+        if (!response.writableEnded)
+            response.end();
+    };
+    const next = () => {
+        if (closed || child !== null)
+            return;
+        if (waiting) {
+            clearTimeout(waiting);
+            waiting = null;
+        }
+        const snapshot = engine.snapshot();
+        const source = engine.trackPath(snapshot.index);
+        if (source === undefined) {
+            // A playlist that was replaced out from under us, or one that is empty
+            // for the moment. Keep the connection and keep looking.
+            later(LIVE_IDLE_MS, next);
+            return;
+        }
+        playing = snapshot.index;
+        const spawned = spawn(command, [
+            ...prefix,
+            "-hide_banner",
+            "-loglevel", "error",
+            ...(isRemote(source) ? ["-reconnect", "1", "-reconnect_streamed", "1", "-reconnect_delay_max", "5"] : []),
+            "-re",
+            "-i", source,
+            "-vn",
+            "-f", "mp3",
+            "-b:a", "192k",
+            "-",
+        ], { stdio: ["ignore", "pipe", "pipe"] });
+        child = spawned;
+        spawned.stdout.once("data", begin);
+        spawned.stdout.on("error", () => spawned.kill("SIGKILL"));
+        // end: false, because the response outlives this track. Ending it here is
+        // exactly the bug this endpoint exists to avoid.
+        spawned.stdout.pipe(response, { end: false });
+        spawned.stderr.resume();
+        spawned.on("error", stop);
+        spawned.on("close", () => {
+            if (child !== spawned)
+                return;
+            child = null;
+            if (closed)
+                return;
+            // Follow the player if it has already moved on. If it has not, look
+            // again shortly -- which is also what makes a single-track library
+            // repeat rather than fall silent.
+            later(engine.snapshot().index === playing ? LIVE_GAP_MS : 0, next);
+        });
+    };
+    // A track change that lands while we are between songs is the signal to go
+    // now rather than wait out the poll.
+    const unsubscribe = engine.subscribe(() => {
+        if (child === null && !closed && engine.snapshot().index !== playing)
+            next();
+    });
+    response.on("close", stop);
+    response.on("error", stop);
+    request.on("close", stop);
+    next();
+}
 /**
  * Decode anything and hand back MP3, as it is produced.
  *
@@ -1222,11 +1614,150 @@ export async function serve(argv, version = "0.1.0") {
     // The account signed in on this machine owns the server it starts. That is
     // the whole claim: `nixamp login` then `nixamp serve`, and the phone in your
     // pocket can administer it from anywhere by signing in as the same person.
+    // Following outlives every stream, so unlike the rest of this it wants a
+    // database. Only where there is one: a nixamp on a laptop has no followers.
+    const pool = options.directory && process.env["DATABASE_URL"]
+        ? new pg.Pool({ connectionString: process.env["DATABASE_URL"] })
+        : undefined;
+    const follows = pool ? new Follows(pool) : undefined;
+    // The two things that were promises kept only in memory: a caller who was
+    // told they would be texted, and the ended stream a code still points at.
+    const durable = pool ? new Durable(pool, (message) => console.log(message)) : undefined;
+    const vapidPublicKey = process.env["VAPID_PUBLIC_KEY"] ?? "";
+    const vapidPrivateKey = process.env["VAPID_PRIVATE_KEY"] ?? "";
+    /**
+     * Tell a broadcaster's followers, on whatever they asked to be told on.
+     *
+     * Fired from the directory on the transition to live rather than on every
+     * heartbeat, and awaited by nobody: a publisher's heartbeat should not sit
+     * waiting on a push service.
+     */
+    const tellFollowers = (listing) => {
+        if (follows === undefined || !listing.ownerId)
+            return;
+        const what = listing.nowPlaying ? ` Playing ${listing.nowPlaying}.` : "";
+        const note = {
+            title: `${listing.name} is live`,
+            body: `${what} Listen at ${DEFAULT_DIRECTORY}/directory, or call ${CALL_IN_NUMBER} and key ${listing.code}.`.trim(),
+            url: listing.url,
+        };
+        void follows
+            .audience(listing.ownerId)
+            .then((audience) => notifyAll(audience, note, {
+            ...(process.env["RESEND_API_KEY"]
+                ? {
+                    email: resendEmail({
+                        apiKey: process.env["RESEND_API_KEY"],
+                        from: process.env["NIXAMP_MAIL_FROM"] ?? "nixamp <notifications@nixamp.com>",
+                        onEvent: (message) => console.log(message),
+                    }),
+                }
+                : {}),
+            ...(process.env["TELNYX_API_KEY"] && process.env["PARTYLINE_SMS_FROM"]
+                ? {
+                    sms: telnyxSms({
+                        apiKey: process.env["TELNYX_API_KEY"],
+                        from: process.env["PARTYLINE_SMS_FROM"],
+                        onEvent: (message) => console.log(message),
+                    }),
+                }
+                : {}),
+            ...(vapidPublicKey && vapidPrivateKey
+                ? {
+                    push: webPush({
+                        publicKey: vapidPublicKey,
+                        privateKey: vapidPrivateKey,
+                        subject: process.env["NIXAMP_SITE"] ?? DEFAULT_DIRECTORY,
+                        onEvent: (message) => console.log(message),
+                    }),
+                }
+                : {}),
+            // A subscription the vendor has retired is a row to delete, not a
+            // failure to retry.
+            onGone: (endpoint) => follows.removePush(endpoint),
+            onEvent: (message) => console.log(message),
+        }))
+            .catch(() => { });
+    };
+    // Hoisted rather than built inline, because the party line needs the same
+    // instance: a second Directory would be a second set of stream codes, and
+    // the one the phone looked in would never be the one the publishers reach.
+    const directory = options.directory
+        ? new Directory(undefined, undefined, undefined, tellFollowers)
+        : undefined;
+    if (directory && durable) {
+        // Echoed rather than awaited: the directory answers from memory, so a
+        // database that is briefly unreachable should cost the durability and not
+        // the request.
+        directory.persistTo({
+            save: (item) => void durable.saveEnded(item),
+            drop: (id) => void durable.dropEnded(id),
+        });
+        // And put back what the last process knew, without holding up the listen.
+        void durable
+            .loadEnded(Date.now() - ENDED_TTL_MS)
+            .then((items) => {
+            if (items.length > 0)
+                console.log(`  remembered ${items.length} stream(s) that had ended.`);
+            directory.seedEnded(items);
+        })
+            .catch(() => { });
+        void durable.sweep(Date.now() - ENDED_TTL_MS, new Date(Date.now() - 30 * 24 * 60 * 60 * 1000));
+    }
     const session = readSession();
     const owner = new Owner({
         ownerId: options.owner || (session?.token ? await ownerIdOf(session) : ""),
         site: session?.site ?? DEFAULT_DIRECTORY,
     });
+    // The party line answers a phone number, and there is only one number. Both
+    // keys or neither: without the public key every webhook would be refused,
+    // which is a worse failure than not offering the endpoint.
+    const partyLine = options.directory && process.env["TELNYX_API_KEY"] && process.env["TELNYX_PUBLIC_KEY"]
+        ? new PartyLine({
+            apiKey: process.env["TELNYX_API_KEY"],
+            publicKey: process.env["TELNYX_PUBLIC_KEY"],
+            streams: directory,
+            callIn: CALL_IN_NUMBER,
+            // Only when a sending number is configured. Without one the line
+            // still answers and still says when the stream ended; it just does
+            // not offer a text it could not send.
+            ...(process.env["PARTYLINE_SMS_FROM"]
+                ? {
+                    sms: telnyxSms({
+                        apiKey: process.env["TELNYX_API_KEY"],
+                        from: process.env["PARTYLINE_SMS_FROM"],
+                        onEvent: (message) => console.log(message),
+                    }),
+                }
+                : {}),
+            ...(process.env["PARTYLINE_GREETING"] ? { greeting: process.env["PARTYLINE_GREETING"] } : {}),
+            ...(process.env["PARTYLINE_VOICE"] ? { voice: process.env["PARTYLINE_VOICE"] } : {}),
+            onEvent: (message) => console.log(message),
+        })
+        : undefined;
+    if (partyLine && durable) {
+        // Put back everybody a previous process promised to text, then keep
+        // echoing. Seeding first means a stream that goes live during startup
+        // still finds them.
+        void durable
+            .loadReminders()
+            .then((waiting) => {
+            const owed = [...waiting.values()].reduce((n, set) => n + set.size, 0);
+            if (owed > 0)
+                console.log(`  ${owed} caller(s) are still owed a text.`);
+            partyLine.persistRemindersTo({
+                add: (code, phone) => void durable.addReminder(code, phone),
+                take: (code) => durable.takeReminders(code),
+            }, waiting);
+        })
+            .catch(() => {
+            // Still worth echoing new ones even if the old list could not be read.
+            partyLine.persistRemindersTo({
+                add: (code, phone) => void durable.addReminder(code, phone),
+                take: (code) => durable.takeReminders(code),
+            });
+        });
+    }
     const server = createServer(engine, {
         web,
         media: options.media,
@@ -1242,7 +1773,9 @@ export async function serve(argv, version = "0.1.0") {
         paywall,
         ffmpeg: tools.ffmpeg,
         load: (next) => loadSource(tools, next),
-        ...(options.directory ? { directory: new Directory() } : {}),
+        ...(directory ? { directory } : {}),
+        ...(follows ? { follows, vapidPublicKey } : {}),
+        ...(partyLine ? { partyLine } : {}),
         // Accounts live where the directory lives, and only there: a nixamp on a
         // laptop has nobody to be an account of.
         ...(options.directory && process.env["DATABASE_URL"]
@@ -1388,6 +1921,10 @@ export async function serve(argv, version = "0.1.0") {
     let publisher = null;
     if (options.publish !== "no" && publishable_) {
         const listen = shareLink(publishable_.url, listenKey);
+        // Announced next to the listen link, not instead of it: one is for a person
+        // with a browser, the other for the phone line and anything else that is
+        // handed one address and expected to play it.
+        const audio = audioLink(publishable_.url, listenKey);
         const wanted = options.publish === "yes"
             ? true
             : await confirm(`\n  List this stream at ${DEFAULT_DIRECTORY}/directory so anyone can find it?\n  It publishes ${listen} — listen only, not the controls.`);
@@ -1396,7 +1933,17 @@ export async function serve(argv, version = "0.1.0") {
                 directory: DEFAULT_DIRECTORY,
                 name: options.name || hostname(),
                 url: listen,
+                audio,
                 tracks: tracks.length,
+                // From `nixamp login`. The directory will not list a stream it cannot
+                // attribute to somebody, because a listing is now a phone code that
+                // costs money to answer.
+                ...(session?.token ? { token: session.token } : {}),
+                onRefused: () => {
+                    console.log("");
+                    console.log("  nixamp.com would not list this stream: it needs an account.");
+                    console.log("  Run `nixamp login` (or `nixamp signup`) and start again.");
+                },
                 nowPlaying: () => {
                     const snapshot = engine.snapshot();
                     return snapshot.tracks[snapshot.index]?.title ?? "";

package/dist/share.d.ts

@@ -37,6 +37,16 @@ export declare function reachableAddresses(host: string, port: number): {
 }[];
 /** The full link, key and all. */
 export declare function shareLink(base: string, key: string | null): string;
+/**
+ * The same stream, as bytes rather than as a page.
+ *
+ * A share link is for a browser: it answers 302, leaves a cookie behind and
+ * redirects to the player. Anything that cannot hold a cookie -- the phone
+ * line, curl, ffplay -- gets a 401 from it and no audio. This carries the key
+ * in the query instead, which keyFrom() accepts, so a single anonymous GET is
+ * enough to start hearing sound.
+ */
+export declare function audioLink(base: string, key: string | null): string;
 /**
  * What a key is allowed to do. An unknown key is allowed nothing, which is the
  * same answer as no key at all.