nixamp 0.7.39 → 0.7.41

package/dist/directory.d.ts

@@ -53,6 +53,14 @@ export interface Listing {
     audio: string;
     tracks: number;
     nowPlaying: string;
+    /**
+     * Whether the server's own player is running. A listing used to say only
+     * what was loaded, so a stopped server read as a live stream of a film
+     * nobody was watching.
+     */
+    playing: boolean;
+    /** The live channels on it, by name: what a visitor could actually watch. */
+    channels: string[];
     /** Set by the directory from the request, never by the publisher. */
     updatedAt: number;
     /** When this stream first announced itself: the "started at" a caller hears. */
@@ -90,6 +98,10 @@ export interface Announcement {
     audio?: string;
     tracks: number;
     nowPlaying: string;
+    /** Absent from an older publisher, which is read as "unknown, say playing". */
+    playing?: boolean;
+    /** Names of the live channels on it. Absent from an older publisher. */
+    channels?: string[];
 }
 /** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
 export declare function clean(value: unknown, max: number): string;

package/dist/directory.js

@@ -20,6 +20,8 @@ export const DEFAULT_DIRECTORY = "https://nixamp.com";
 export const ENDED_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_NAME = 60;
 const MAX_TRACK = 120;
+/** How many channel names a listing carries. A multiview is four; eight is plenty. */
+const MAX_CHANNELS = 8;
 /** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
 export function clean(value, max) {
     if (typeof value !== "string")
@@ -75,6 +77,15 @@ export function parseAnnouncement(input) {
         ...(audio ? { audio } : {}),
         tracks: Number.isFinite(tracks) && tracks >= 0 ? Math.min(1_000_000, Math.floor(tracks)) : 0,
         nowPlaying: clean(record["nowPlaying"], MAX_TRACK),
+        ...(typeof record["playing"] === "boolean" ? { playing: record["playing"] } : {}),
+        ...(Array.isArray(record["channels"])
+            ? {
+                channels: record["channels"]
+                    .map((one) => clean(one, MAX_NAME))
+                    .filter((one) => one !== "")
+                    .slice(0, MAX_CHANNELS),
+            }
+            : {}),
     };
 }
 /**
@@ -158,6 +169,10 @@ export class Directory {
             audio: announcement.audio ?? existing?.audio ?? "",
             tracks: announcement.tracks,
             nowPlaying: announcement.nowPlaying,
+            // An older publisher says nothing about either; "playing" keeps what a
+            // listing always meant, and no channels is the honest empty list.
+            playing: announcement.playing ?? true,
+            channels: announcement.channels ?? [],
             updatedAt: this.now(),
             // A stream that never stopped keeps its original start. One that did
             // starts again now, because that is what a caller is being told about.

package/dist/favorites.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The servers an account has hearted.
+ *
+ * Distinct from following, which is about a person -- being told when they go
+ * live -- and from "your servers", which are the machines you run. A
+ * favourite is a place you like to go back to: somebody else's server, kept by
+ * its address, with the name it had when you hearted it so the list reads as
+ * names rather than URLs.
+ *
+ * Kept on nixamp.com against the account, like follows, and reached by the
+ * same session. Listening needs no account; remembering where you listened
+ * does.
+ */
+import type { Queryable } from "./follows.ts";
+export interface Favorite {
+    url: string;
+    name: string;
+    addedAt: number;
+}
+/** A server address worth keeping: http(s), and nothing a browser cannot open. */
+export declare function favoriteUrl(raw: unknown): string;
+export declare class Favorites {
+    private readonly db;
+    private ready;
+    constructor(db: Queryable);
+    private ensure;
+    /** Heart it. Hearting it again keeps the newer name. */
+    add(accountId: string, url: string, name: string): Promise<boolean>;
+    remove(accountId: string, url: string): Promise<void>;
+    list(accountId: string): Promise<Favorite[]>;
+    has(accountId: string, url: string): Promise<boolean>;
+}

package/dist/favorites.js

@@ -0,0 +1,65 @@
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS favorites (
+    account_id  TEXT NOT NULL,
+    url         TEXT NOT NULL,
+    name        TEXT NOT NULL DEFAULT '',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (account_id, url)
+  );
+`;
+const MAX_URL = 500;
+const MAX_NAME = 60;
+/** A server address worth keeping: http(s), and nothing a browser cannot open. */
+export function favoriteUrl(raw) {
+    if (typeof raw !== "string")
+        return "";
+    const text = raw.trim().slice(0, MAX_URL);
+    try {
+        const url = new URL(text);
+        if (url.protocol !== "http:" && url.protocol !== "https:")
+            return "";
+        return text;
+    }
+    catch {
+        return "";
+    }
+}
+export class Favorites {
+    db;
+    ready = null;
+    constructor(db) {
+        this.db = db;
+    }
+    async ensure() {
+        this.ready ??= this.db.query(SCHEMA).then(() => undefined);
+        await this.ready;
+    }
+    /** Heart it. Hearting it again keeps the newer name. */
+    async add(accountId, url, name) {
+        const address = favoriteUrl(url);
+        if (!accountId || !address)
+            return false;
+        await this.ensure();
+        await this.db.query(`INSERT INTO favorites (account_id, url, name) VALUES ($1, $2, $3)
+       ON CONFLICT (account_id, url) DO UPDATE SET name = EXCLUDED.name`, [accountId, address, String(name ?? "").trim().slice(0, MAX_NAME)]);
+        return true;
+    }
+    async remove(accountId, url) {
+        await this.ensure();
+        await this.db.query("DELETE FROM favorites WHERE account_id = $1 AND url = $2", [accountId, url]);
+    }
+    async list(accountId) {
+        await this.ensure();
+        const { rows } = await this.db.query("SELECT url, name, created_at FROM favorites WHERE account_id = $1 ORDER BY created_at", [accountId]);
+        return rows.map((row) => ({
+            url: String(row["url"] ?? ""),
+            name: String(row["name"] ?? ""),
+            addedAt: new Date(String(row["created_at"] ?? 0)).getTime() || 0,
+        }));
+    }
+    async has(accountId, url) {
+        await this.ensure();
+        const { rows } = await this.db.query("SELECT 1 FROM favorites WHERE account_id = $1 AND url = $2", [accountId, url]);
+        return rows.length > 0;
+    }
+}

package/dist/publish.d.ts

@@ -21,6 +21,10 @@ export interface PublishTarget {
      */
     tracks: () => number;
     nowPlaying: () => string;
+    /** Whether the player is actually running, so a stopped server is not listed as live. */
+    playing?: () => boolean;
+    /** The live channels on this server, by name, for the listing to show. */
+    channels?: () => string[];
     /**
      * The account this stream belongs to, from `nixamp login`.
      *

package/dist/publish.js

@@ -60,6 +60,8 @@ export class Publisher {
                     ...(this.target.audio ? { audio: this.target.audio } : {}),
                     tracks: this.target.tracks(),
                     nowPlaying: this.target.nowPlaying(),
+                    ...(this.target.playing ? { playing: this.target.playing() } : {}),
+                    ...(this.target.channels ? { channels: this.target.channels() } : {}),
                 }),
             });
             if (!response.ok) {

package/dist/server.d.ts

@@ -12,6 +12,7 @@ import { Owner } from "./owner.ts";
 import { Directory } from "./directory.ts";
 import { PartyLine } from "./partyline.ts";
 import { Follows } from "./follows.ts";
+import { Favorites } from "./favorites.ts";
 import { type Tools, type Track } from "./audio.ts";
 import { type Command, type RemoteTrack, type Snapshot } from "./protocol.ts";
 export declare const SERVE_BAND_COUNT = 24;
@@ -508,6 +509,8 @@ export interface HandlerOptions {
      * the stream.
      */
     follows?: Follows;
+    /** The servers an account hearted. nixamp.com only, like follows. */
+    favorites?: Favorites;
     /** The VAPID public key a browser needs before it can subscribe. */
     vapidPublicKey?: string;
 }

package/dist/server.js

@@ -37,6 +37,7 @@ 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 { Favorites, favoriteUrl } from "./favorites.js";
 import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
@@ -910,6 +911,65 @@ export function createHandler(engine, options) {
         // 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.
+        // Favourites: the servers you hearted, kept against your account. Reading
+        // the directory and listening need no account; remembering where you
+        // listened does, because there has to be somebody to remember it for.
+        if (path === "/api/v1/favorites" && options.favorites && options.accounts) {
+            const me = await options.accounts.whoIs(tokenFrom(request.headers));
+            if (me === null) {
+                json(response, 401, { error: "sign in to keep favourites" });
+                return;
+            }
+            const favorites = options.favorites;
+            if (request.method === "GET") {
+                const list = await favorites.list(me.id);
+                // Whether each is on right now, from the directory: a favourite that
+                // is live is the one to click first.
+                const live = new Map((options.directory?.list() ?? []).map((one) => [one.url, one]));
+                json(response, 200, {
+                    favorites: list.map((one) => {
+                        const on = live.get(one.url);
+                        return {
+                            ...one,
+                            live: on !== undefined,
+                            nowPlaying: on?.playing ? on.nowPlaying : "",
+                            channels: on?.channels ?? [],
+                        };
+                    }),
+                });
+                return;
+            }
+            if (request.method === "PUT" || request.method === "POST") {
+                let body = {};
+                try {
+                    body = JSON.parse(await readBody(request));
+                }
+                catch {
+                    json(response, 400, { error: "bad JSON" });
+                    return;
+                }
+                const address = favoriteUrl(body.url);
+                if (!address) {
+                    json(response, 400, { error: "give the server's address" });
+                    return;
+                }
+                await favorites.add(me.id, address, typeof body.name === "string" ? body.name : "");
+                json(response, 200, { favorite: true });
+                return;
+            }
+            if (request.method === "DELETE") {
+                const address = favoriteUrl(url.searchParams.get("url"));
+                if (!address) {
+                    json(response, 400, { error: "give the server's address" });
+                    return;
+                }
+                await favorites.remove(me.id, address);
+                json(response, 200, { favorite: false });
+                return;
+            }
+            json(response, 405, { error: "GET, PUT or DELETE" });
+            return;
+        }
         if (path.startsWith("/api/v1/follows") && options.follows && options.accounts) {
             const me = await options.accounts.whoIs(tokenFrom(request.headers));
             if (me === null) {
@@ -2865,6 +2925,7 @@ export async function serve(argv, version = "0.1.0") {
         ? new pg.Pool({ connectionString: process.env["DATABASE_URL"] })
         : undefined;
     const follows = pool ? new Follows(pool) : undefined;
+    const favorites = pool ? new Favorites(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;
@@ -3088,6 +3149,7 @@ export async function serve(argv, version = "0.1.0") {
         tag: (next) => loadTagged(tools, next),
         ...(directory ? { directory } : {}),
         ...(follows ? { follows, vapidPublicKey } : {}),
+        ...(favorites ? { favorites } : {}),
         ...(partyLine ? { partyLine } : {}),
         // Accounts live where the directory lives, and only there: a nixamp on a
         // laptop has nobody to be an account of.
@@ -3338,6 +3400,11 @@ export async function serve(argv, version = "0.1.0") {
             // Asked at every heartbeat rather than once, because the library is
             // read after the port opens and is still arriving when this is made.
             tracks: () => engine.snapshot(false).trackCount,
+            // What a visitor would find here: whether the player is running, and
+            // which channels are on. A directory row that says "5,717 files,
+            // live: CNN" is one somebody can decide about; "5717 tracks" was not.
+            playing: () => engine.snapshot(false).playing,
+            channels: () => channels.list().map((one) => one.name),
             // 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.

package/dist/session.js

@@ -357,20 +357,31 @@ export async function chooseWay(ways, options) {
     if (options.device)
         return ways.device ? "device" : null;
     // Naming an address is asking for the password flow by implication.
-    if (!ways.device || options.email || !process.stdin.isTTY)
-        return "password";
-    if (ways.providers.length === 0)
+    if (!ways.device || options.email)
         return "password";
+    // A site with no providers configured still has a browser to approve in,
+    // and that is the way in from a terminal: a code, a page, a click. This
+    // used to fall through to a password prompt the moment the provider list
+    // was empty, which is what nixamp.com answers, so nobody ever saw the
+    // browser flow that was built for exactly this. With no terminal to draw
+    // a menu on, the browser page offers the providers instead.
+    if (ways.providers.length === 0 || !process.stdin.isTTY)
+        return "device";
     console.log("How would you like to sign in?");
     ways.providers.forEach((provider, index) => console.log(`  ${index + 1}) ${provider.name}`));
-    console.log(`  ${ways.providers.length + 1}) Email and password`);
+    console.log(`  ${ways.providers.length + 1}) In a browser you are already signed in to`);
+    console.log(`  ${ways.providers.length + 2}) Email and password`);
     const typed = await ask(`Choose [1]: `);
     const picked = typed === "" ? 1 : Number(typed);
-    if (!Number.isInteger(picked) || picked < 1 || picked > ways.providers.length + 1) {
-        console.log("Not one of those, so: email and password.");
-        return "password";
+    if (!Number.isInteger(picked) || picked < 1 || picked > ways.providers.length + 2) {
+        console.log("Not one of those, so: in a browser.");
+        return "device";
     }
-    return picked === ways.providers.length + 1 ? "password" : (ways.providers[picked - 1]?.id ?? "password");
+    if (picked === ways.providers.length + 1)
+        return "device";
+    if (picked === ways.providers.length + 2)
+        return "password";
+    return ways.providers[picked - 1]?.id ?? "device";
 }
 const day = (at) => (at ? new Date(at).toISOString().slice(0, 10) : "never");
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.7.39",
+  "version": "0.7.41",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",

package/src/directory.ts

@@ -57,6 +57,14 @@ export interface Listing {
   audio: string;
   tracks: number;
   nowPlaying: string;
+  /**
+   * Whether the server's own player is running. A listing used to say only
+   * what was loaded, so a stopped server read as a live stream of a film
+   * nobody was watching.
+   */
+  playing: boolean;
+  /** The live channels on it, by name: what a visitor could actually watch. */
+  channels: string[];
   /** Set by the directory from the request, never by the publisher. */
   updatedAt: number;
   /** When this stream first announced itself: the "started at" a caller hears. */
@@ -97,10 +105,16 @@ export interface Announcement {
   audio?: string;
   tracks: number;
   nowPlaying: string;
+  /** Absent from an older publisher, which is read as "unknown, say playing". */
+  playing?: boolean;
+  /** Names of the live channels on it. Absent from an older publisher. */
+  channels?: string[];
 }
 
 const MAX_NAME = 60;
 const MAX_TRACK = 120;
+/** How many channel names a listing carries. A multiview is four; eight is plenty. */
+const MAX_CHANNELS = 8;
 
 /** Trim and flatten, so one publisher cannot draw a box in someone's terminal. */
 export function clean(value: unknown, max: number): string {
@@ -156,6 +170,15 @@ export function parseAnnouncement(input: unknown): Announcement | null {
     ...(audio ? { audio } : {}),
     tracks: Number.isFinite(tracks) && tracks >= 0 ? Math.min(1_000_000, Math.floor(tracks)) : 0,
     nowPlaying: clean(record["nowPlaying"], MAX_TRACK),
+    ...(typeof record["playing"] === "boolean" ? { playing: record["playing"] } : {}),
+    ...(Array.isArray(record["channels"])
+      ? {
+          channels: (record["channels"] as unknown[])
+            .map((one) => clean(one, MAX_NAME))
+            .filter((one) => one !== "")
+            .slice(0, MAX_CHANNELS),
+        }
+      : {}),
   };
 }
 
@@ -240,6 +263,10 @@ export class Directory {
       audio: announcement.audio ?? existing?.audio ?? "",
       tracks: announcement.tracks,
       nowPlaying: announcement.nowPlaying,
+      // An older publisher says nothing about either; "playing" keeps what a
+      // listing always meant, and no channels is the honest empty list.
+      playing: announcement.playing ?? true,
+      channels: announcement.channels ?? [],
       updatedAt: this.now(),
       // A stream that never stopped keeps its original start. One that did
       // starts again now, because that is what a caller is being told about.

package/src/favorites.ts

@@ -0,0 +1,97 @@
+/**
+ * The servers an account has hearted.
+ *
+ * Distinct from following, which is about a person -- being told when they go
+ * live -- and from "your servers", which are the machines you run. A
+ * favourite is a place you like to go back to: somebody else's server, kept by
+ * its address, with the name it had when you hearted it so the list reads as
+ * names rather than URLs.
+ *
+ * Kept on nixamp.com against the account, like follows, and reached by the
+ * same session. Listening needs no account; remembering where you listened
+ * does.
+ */
+import type { Queryable } from "./follows.ts";
+
+export interface Favorite {
+  url: string;
+  name: string;
+  addedAt: number;
+}
+
+const SCHEMA = `
+  CREATE TABLE IF NOT EXISTS favorites (
+    account_id  TEXT NOT NULL,
+    url         TEXT NOT NULL,
+    name        TEXT NOT NULL DEFAULT '',
+    created_at  TIMESTAMPTZ NOT NULL DEFAULT now(),
+    PRIMARY KEY (account_id, url)
+  );
+`;
+
+const MAX_URL = 500;
+const MAX_NAME = 60;
+
+/** A server address worth keeping: http(s), and nothing a browser cannot open. */
+export function favoriteUrl(raw: unknown): string {
+  if (typeof raw !== "string") return "";
+  const text = raw.trim().slice(0, MAX_URL);
+  try {
+    const url = new URL(text);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return "";
+    return text;
+  } catch {
+    return "";
+  }
+}
+
+export class Favorites {
+  private ready: Promise<void> | null = null;
+
+  constructor(private readonly db: Queryable) {}
+
+  private async ensure(): Promise<void> {
+    this.ready ??= this.db.query(SCHEMA).then(() => undefined);
+    await this.ready;
+  }
+
+  /** Heart it. Hearting it again keeps the newer name. */
+  async add(accountId: string, url: string, name: string): Promise<boolean> {
+    const address = favoriteUrl(url);
+    if (!accountId || !address) return false;
+    await this.ensure();
+    await this.db.query(
+      `INSERT INTO favorites (account_id, url, name) VALUES ($1, $2, $3)
+       ON CONFLICT (account_id, url) DO UPDATE SET name = EXCLUDED.name`,
+      [accountId, address, String(name ?? "").trim().slice(0, MAX_NAME)],
+    );
+    return true;
+  }
+
+  async remove(accountId: string, url: string): Promise<void> {
+    await this.ensure();
+    await this.db.query("DELETE FROM favorites WHERE account_id = $1 AND url = $2", [accountId, url]);
+  }
+
+  async list(accountId: string): Promise<Favorite[]> {
+    await this.ensure();
+    const { rows } = await this.db.query(
+      "SELECT url, name, created_at FROM favorites WHERE account_id = $1 ORDER BY created_at",
+      [accountId],
+    );
+    return rows.map((row) => ({
+      url: String(row["url"] ?? ""),
+      name: String(row["name"] ?? ""),
+      addedAt: new Date(String(row["created_at"] ?? 0)).getTime() || 0,
+    }));
+  }
+
+  async has(accountId: string, url: string): Promise<boolean> {
+    await this.ensure();
+    const { rows } = await this.db.query(
+      "SELECT 1 FROM favorites WHERE account_id = $1 AND url = $2",
+      [accountId, url],
+    );
+    return rows.length > 0;
+  }
+}

package/src/publish.ts

@@ -30,6 +30,10 @@ export interface PublishTarget {
    */
   tracks: () => number;
   nowPlaying: () => string;
+  /** Whether the player is actually running, so a stopped server is not listed as live. */
+  playing?: () => boolean;
+  /** The live channels on this server, by name, for the listing to show. */
+  channels?: () => string[];
   /**
    * The account this stream belongs to, from `nixamp login`.
    *
@@ -101,6 +105,8 @@ export class Publisher {
           ...(this.target.audio ? { audio: this.target.audio } : {}),
           tracks: this.target.tracks(),
           nowPlaying: this.target.nowPlaying(),
+          ...(this.target.playing ? { playing: this.target.playing() } : {}),
+          ...(this.target.channels ? { channels: this.target.channels() } : {}),
         }),
       });
       if (!response.ok) {

package/src/server.ts

@@ -54,6 +54,7 @@ import { PartyLine, telnyxSms } from "./partyline.ts";
 import { CALL_IN_NUMBER, OPT_IN_PATH, optInPage } from "./optin.ts";
 import pg from "pg";
 import { Follows, phoneFrom } from "./follows.ts";
+import { Favorites, favoriteUrl } from "./favorites.ts";
 import { Durable } from "./durable.ts";
 import { notifyAll, resendEmail, webPush, type Notification } from "./notify.ts";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.ts";
@@ -1168,6 +1169,8 @@ export interface HandlerOptions {
    * the stream.
    */
   follows?: Follows;
+  /** The servers an account hearted. nixamp.com only, like follows. */
+  favorites?: Favorites;
   /** The VAPID public key a browser needs before it can subscribe. */
   vapidPublicKey?: string;
 }
@@ -1258,6 +1261,68 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     // 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.
+    // Favourites: the servers you hearted, kept against your account. Reading
+    // the directory and listening need no account; remembering where you
+    // listened does, because there has to be somebody to remember it for.
+    if (path === "/api/v1/favorites" && options.favorites && options.accounts) {
+      const me = await options.accounts.whoIs(tokenFrom(request.headers));
+      if (me === null) {
+        json(response, 401, { error: "sign in to keep favourites" });
+        return;
+      }
+      const favorites = options.favorites;
+
+      if (request.method === "GET") {
+        const list = await favorites.list(me.id);
+        // Whether each is on right now, from the directory: a favourite that
+        // is live is the one to click first.
+        const live = new Map((options.directory?.list() ?? []).map((one) => [one.url, one]));
+        json(response, 200, {
+          favorites: list.map((one) => {
+            const on = live.get(one.url);
+            return {
+              ...one,
+              live: on !== undefined,
+              nowPlaying: on?.playing ? on.nowPlaying : "",
+              channels: on?.channels ?? [],
+            };
+          }),
+        });
+        return;
+      }
+
+      if (request.method === "PUT" || request.method === "POST") {
+        let body: { url?: unknown; name?: unknown } = {};
+        try {
+          body = JSON.parse(await readBody(request)) as typeof body;
+        } catch {
+          json(response, 400, { error: "bad JSON" });
+          return;
+        }
+        const address = favoriteUrl(body.url);
+        if (!address) {
+          json(response, 400, { error: "give the server's address" });
+          return;
+        }
+        await favorites.add(me.id, address, typeof body.name === "string" ? body.name : "");
+        json(response, 200, { favorite: true });
+        return;
+      }
+
+      if (request.method === "DELETE") {
+        const address = favoriteUrl(url.searchParams.get("url"));
+        if (!address) {
+          json(response, 400, { error: "give the server's address" });
+          return;
+        }
+        await favorites.remove(me.id, address);
+        json(response, 200, { favorite: false });
+        return;
+      }
+      json(response, 405, { error: "GET, PUT or DELETE" });
+      return;
+    }
+
     if (path.startsWith("/api/v1/follows") && options.follows && options.accounts) {
       const me = await options.accounts.whoIs(tokenFrom(request.headers));
       if (me === null) {
@@ -3350,6 +3415,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
       ? new pg.Pool({ connectionString: process.env["DATABASE_URL"] })
       : undefined;
   const follows = pool ? new Follows(pool) : undefined;
+  const favorites = pool ? new Favorites(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;
@@ -3585,6 +3651,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     tag: (next) => loadTagged(tools, next),
     ...(directory ? { directory } : {}),
     ...(follows ? { follows, vapidPublicKey } : {}),
+    ...(favorites ? { favorites } : {}),
     ...(partyLine ? { partyLine } : {}),
     // Accounts live where the directory lives, and only there: a nixamp on a
     // laptop has nobody to be an account of.
@@ -3858,6 +3925,11 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
         // Asked at every heartbeat rather than once, because the library is
         // read after the port opens and is still arriving when this is made.
         tracks: () => engine.snapshot(false).trackCount,
+        // What a visitor would find here: whether the player is running, and
+        // which channels are on. A directory row that says "5,717 files,
+        // live: CNN" is one somebody can decide about; "5717 tracks" was not.
+        playing: () => engine.snapshot(false).playing,
+        channels: () => channels.list().map((one) => one.name),
         // 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.