nixamp 0.21.4 → 0.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nixamp",
-  "version": "0.21.4",
+  "version": "0.22.0",
   "description": "It really whips the terminal's ass. A Winamp-shaped audio player for your terminal.",
   "license": "MIT",
   "type": "module",
@@ -45,13 +45,16 @@
   },
   "dependencies": {
     "@profullstack/auth-system": "^0.6.0",
-    "@profullstack/hqtui": "^0.3.0",
+    "@profullstack/hqtui": "^0.5.0",
     "@profullstack/throttle": "0.2.2",
     "@profullstack/x402-gateway": "0.6.0",
     "acme-client": "5.4.0",
     "pg": "^8.23.0",
     "web-push": "^3.6.7"
   },
+  "optionalDependencies": {
+    "@huggingface/transformers": "^4.2.0"
+  },
   "devDependencies": {
     "@types/node": "^26",
     "@types/pg": "^8.23.1",

package/src/captions.ts

@@ -0,0 +1,334 @@
+/**
+ * Captions: what a live channel is saying, written down as it says it.
+ *
+ * One captioner per channel, started when the first person asks for the
+ * transcript and stopped a minute after the last one leaves, because it
+ * costs a CPU somewhere for as long as it runs. It listens to the channel
+ * exactly as a browser does -- the same bytes, from the same backlog --
+ * hands them to an ffmpeg that turns them into 16 kHz mono PCM, cuts that
+ * into five-second windows, and sends each window to nixamp.com's ear
+ * (see speech.ts) signed in as this server. The words come back as a
+ * line, stamped with the wall-clock moment the sound was heard, so a page
+ * can hold each line until its own playback gets there and the subtitles
+ * land close to the voice.
+ *
+ * Five seconds is the trade. Shorter windows hear less context and cost
+ * more asks; longer ones make the words later than the sound. A line is a
+ * window: no word-level timing, because the ear takes twice as long when
+ * asked for it and the page is only ever close to the voice, not on it.
+ *
+ * A quiet window -- the gap between songs, a picture with no talking -- is
+ * never sent. Most of a music channel is that, and hearing it costs the
+ * same as hearing speech.
+ */
+import { spawn } from "node:child_process";
+import type { Listener } from "./channels.ts";
+import { RATE } from "./speech.ts";
+
+export interface CaptionLine {
+  /** The channel's id. */
+  channel: string;
+  /** When the sound this line is from began and ended, wall clock, ms. */
+  at: number;
+  until: number;
+  text: string;
+}
+
+/** What turns a channel's bytes into 16 kHz mono 16-bit PCM. ffmpeg, or a test's stand-in. */
+export interface Decoder {
+  write(chunk: Buffer): boolean;
+  end(): void;
+}
+
+export interface CaptionsOptions {
+  /** A listener on a channel, or null when there is no such channel. */
+  listen: (id: string, listener: Listener) => (() => void) | null;
+  ffmpeg: string[];
+  /** Whose ear to use: this server's own sign-in, read when a captioner starts. Null means no captions. */
+  session: () => { site: string; token: string } | null;
+  fetcher?: typeof fetch;
+  /** How bytes become PCM. The default spawns ffmpeg; the tests hand in something quieter. */
+  decoder?: (onPcm: (pcm: Buffer) => void, onEnd: () => void) => Decoder;
+  now?: () => number;
+  onEvent?: (message: string) => void;
+  windowMs?: number;
+  idleMs?: number;
+}
+
+export const WINDOW_MS = 5000;
+/** Lines kept per channel for whoever arrives late. */
+export const KEEP = 200;
+export const IDLE_MS = 60_000;
+/** Below this RMS (about -48 dBFS) a window is silence, and never sent. */
+export const QUIET = 0.004;
+/** Windows waiting on the ear at once. Past this the sound is dropped, not queued: late words are worse than none. */
+export const IN_FLIGHT = 2;
+
+/**
+ * The ffmpeg arguments: whatever arrives on stdin, as PCM on stdout, with
+ * a short probe so the first line is not long in coming. Never `-fflags
+ * nobuffer`: it drops the packets it probed, which took the first 1.7
+ * seconds out of every captioner and began every transcript mid-sentence.
+ */
+export function decoderArgs(): string[] {
+  return [
+    "-v", "error", "-nostats",
+    "-flags", "low_delay",
+    "-analyzeduration", "500000", "-probesize", "262144",
+    "-i", "pipe:0",
+    "-vn", "-ac", "1", "-ar", String(RATE), "-f", "s16le", "pipe:1",
+  ];
+}
+
+function ffmpegDecoder(ffmpeg: string[], onPcm: (pcm: Buffer) => void, onEnd: () => void): Decoder {
+  const [command, ...prefix] = ffmpeg;
+  const child = spawn(command as string, [...prefix, ...decoderArgs()], { stdio: ["pipe", "pipe", "ignore"] });
+  let ended = false;
+  const end = (): void => {
+    if (ended) return;
+    ended = true;
+    onEnd();
+  };
+  child.stdin.on("error", () => undefined);
+  child.stdout.on("data", (chunk: Buffer) => onPcm(chunk));
+  child.on("error", end);
+  child.on("close", end);
+  return {
+    write: (chunk) => {
+      if (ended || child.stdin.destroyed) return false;
+      try {
+        child.stdin.write(chunk);
+      } catch {
+        return false;
+      }
+      return true;
+    },
+    end: () => {
+      try {
+        child.stdin.end();
+      } catch {
+        // Already gone.
+      }
+      if (!ended) {
+        const kill = setTimeout(() => child.kill("SIGKILL"), 2000);
+        kill.unref?.();
+      }
+    },
+  };
+}
+
+/** Whether a window of 16-bit PCM has anything in it worth hearing. */
+export function isQuiet(pcm: Buffer, threshold = QUIET): boolean {
+  const samples = Math.floor(pcm.length / 2);
+  if (samples === 0) return true;
+  let sum = 0;
+  for (let i = 0; i < samples; i++) {
+    const value = pcm.readInt16LE(i * 2) / 32768;
+    sum += value * value;
+  }
+  return Math.sqrt(sum / samples) < threshold;
+}
+
+/** A WAV around 16-bit mono PCM, without copying it through floats. */
+export function wavAround(pcm: Buffer, rate = RATE): Buffer {
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0, "ascii");
+  header.writeUInt32LE(36 + pcm.length, 4);
+  header.write("WAVE", 8, "ascii");
+  header.write("fmt ", 12, "ascii");
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(rate, 24);
+  header.writeUInt32LE(rate * 2, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36, "ascii");
+  header.writeUInt32LE(pcm.length, 40);
+  return Buffer.concat([header, pcm]);
+}
+
+type Subscriber = (line: CaptionLine) => void;
+
+class Captioner {
+  readonly lines: CaptionLine[] = [];
+  readonly subscribers = new Set<Subscriber>();
+  /** The last thing that went wrong, for whoever asks why there are no lines. */
+  error = "";
+  private decoder: Decoder | null = null;
+  private detach: (() => void) | null = null;
+  private idle: ReturnType<typeof setTimeout> | null = null;
+  private pending: Buffer[] = [];
+  private pendingBytes = 0;
+  private inFlight = 0;
+  private stopped = false;
+  private complainedAt = 0;
+
+  constructor(
+    readonly id: string,
+    private readonly options: CaptionsOptions,
+    private readonly onStop: () => void,
+  ) {}
+
+  private get windowBytes(): number {
+    return Math.round(((this.options.windowMs ?? WINDOW_MS) / 1000) * RATE) * 2;
+  }
+
+  start(): boolean {
+    const make = this.options.decoder ?? ((onPcm, onEnd) => ffmpegDecoder(this.options.ffmpeg, onPcm, onEnd));
+    this.decoder = make((pcm) => this.onPcm(pcm), () => this.stop());
+    this.detach = this.options.listen(this.id, {
+      write: (chunk) => this.decoder?.write(chunk) ?? false,
+      end: () => this.stop(),
+    });
+    if (this.detach === null) {
+      this.stop();
+      return false;
+    }
+    return true;
+  }
+
+  private onPcm(pcm: Buffer): void {
+    if (this.stopped) return;
+    this.pending.push(pcm);
+    this.pendingBytes += pcm.length;
+    const size = this.windowBytes;
+    while (this.pendingBytes >= size) {
+      const all = Buffer.concat(this.pending);
+      const window = all.subarray(0, size);
+      const rest = all.subarray(size);
+      this.pending = rest.length > 0 ? [Buffer.from(rest)] : [];
+      this.pendingBytes = rest.length;
+      const until = (this.options.now ?? Date.now)();
+      void this.hear(Buffer.from(window), until - (this.options.windowMs ?? WINDOW_MS), until);
+    }
+  }
+
+  private async hear(pcm: Buffer, at: number, until: number): Promise<void> {
+    if (isQuiet(pcm)) return;
+    if (this.inFlight >= IN_FLIGHT) return;
+    const session = this.options.session();
+    if (session === null) {
+      this.complain("this server is not signed in, so it cannot caption; `nixamp login` on it");
+      return;
+    }
+    this.inFlight += 1;
+    try {
+      const wav = wavAround(pcm);
+      const response = await (this.options.fetcher ?? fetch)(`${session.site.replace(/\/+$/, "")}/api/v1/speech/transcribe`, {
+        method: "POST",
+        headers: { authorization: `Bearer ${session.token}`, "content-type": "audio/wav" },
+        body: new Blob([wav.buffer.slice(wav.byteOffset, wav.byteOffset + wav.byteLength) as ArrayBuffer]),
+      });
+      const body = (await response.json().catch(() => ({}))) as { text?: string; error?: string };
+      if (!response.ok) {
+        this.complain(body.error ?? `nixamp.com answered ${response.status}`);
+        return;
+      }
+      const text = (body.text ?? "").trim();
+      if (text === "" || this.stopped) return;
+      this.error = "";
+      const line: CaptionLine = { channel: this.id, at, until, text };
+      this.lines.push(line);
+      while (this.lines.length > KEEP) this.lines.shift();
+      for (const subscriber of this.subscribers) {
+        try {
+          subscriber(line);
+        } catch {
+          // A listener that throws is not this channel's problem.
+        }
+      }
+    } catch (error) {
+      this.complain(`could not reach the ear: ${(error as Error).message}`);
+    } finally {
+      this.inFlight -= 1;
+    }
+  }
+
+  /** Said once a minute at most: a broken ear would otherwise say so twelve times a minute. */
+  private complain(message: string): void {
+    this.error = message;
+    const now = (this.options.now ?? Date.now)();
+    if (now - this.complainedAt < 60_000) return;
+    this.complainedAt = now;
+    this.options.onEvent?.(`captions for "${this.id}": ${message}`);
+  }
+
+  subscribe(subscriber: Subscriber): () => void {
+    this.subscribers.add(subscriber);
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = null;
+    return () => {
+      this.subscribers.delete(subscriber);
+      if (this.subscribers.size === 0 && !this.stopped) {
+        this.idle = setTimeout(() => {
+          if (this.subscribers.size === 0) this.stop();
+        }, this.options.idleMs ?? IDLE_MS);
+        this.idle.unref?.();
+      }
+    };
+  }
+
+  stop(): void {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = null;
+    this.detach?.();
+    this.detach = null;
+    this.decoder?.end();
+    this.decoder = null;
+    this.pending = [];
+    this.pendingBytes = 0;
+    this.subscribers.clear();
+    this.onStop();
+  }
+}
+
+export class Captions {
+  private readonly running = new Map<string, Captioner>();
+
+  constructor(private readonly options: CaptionsOptions) {}
+
+  /** Whether this server can caption at all: it has to be signed in for the ear to answer it. */
+  available(): boolean {
+    return this.options.session() !== null;
+  }
+
+  /**
+   * Lines for a channel as they are heard, starting the captioner if it is
+   * not running. Null when there is no such channel. The returned function
+   * is how to stop listening; the captioner itself stops a minute after the
+   * last listener does.
+   */
+  subscribe(id: string, subscriber: Subscriber): (() => void) | null {
+    let captioner = this.running.get(id);
+    if (!captioner) {
+      const made = new Captioner(id, this.options, () => {
+        if (this.running.get(id) === made) this.running.delete(id);
+      });
+      this.running.set(id, made);
+      if (!made.start()) return null;
+      this.options.onEvent?.(`captions for "${id}": started`);
+      captioner = made;
+    }
+    return captioner.subscribe(subscriber);
+  }
+
+  /** The recent lines of a channel, oldest first, after a moment when given. Empty when nobody has asked for them. */
+  recent(id: string, after = 0): CaptionLine[] {
+    const captioner = this.running.get(id);
+    if (!captioner) return [];
+    return after > 0 ? captioner.lines.filter((line) => line.at > after) : [...captioner.lines];
+  }
+
+  /** Whether a channel is being captioned, and what last went wrong if the lines are not coming. */
+  status(id: string): { on: boolean; lines: number; error: string } {
+    const captioner = this.running.get(id);
+    return captioner ? { on: true, lines: captioner.lines.length, error: captioner.error } : { on: false, lines: 0, error: "" };
+  }
+
+  stopAll(): void {
+    for (const captioner of [...this.running.values()]) captioner.stop();
+  }
+}

package/src/main.ts

@@ -83,6 +83,8 @@ const HELP = `nixamp — it really whips the terminal's ass.
   nixamp server list|add|remove  the machines you run, kept against your account
   nixamp party list|join|host   watch parties, here and on the sites nixamp is connected to
   nixamp mcp                     speak Model Context Protocol on stdin, for an agent
+  nixamp transcribe FILE [--say SERVER]  the words in a recording, and into a trollbox
+  nixamp transcript --channel ID [--follow]  what a channel is saying, as it says it
   nixamp opendir list|add|remove  folders found on the web, published for everyone
   nixamp update [version]        re-run the installer, keeping your choices
   nixamp uninstall [--yes]       remove everything the installer created
@@ -262,10 +264,43 @@ takes it away again.
   nixamp mcp    speak Model Context Protocol on stdin and stdout
 
 It offers the watch party tools: list them, read one, put one on the air,
-say where playback is, end it. It acts as whoever this machine is signed in
-as, so \`nixamp login\` (or NIXAMP_TOKEN) comes first.
+say where playback is, end it. And the room tools: transcribe a recording
+(transcribe_audio, which can post the words straight into a trollbox), say a
+line in a room (trollbox_say), read a room (trollbox_read), read what a
+channel is saying (transcript_read). It acts as
+whoever this machine is signed in as, so \`nixamp login\` (or NIXAMP_TOKEN)
+comes first.
 
 Point an MCP client at it as a stdio server running \`nixamp mcp\`.
+`,
+  transcribe: `nixamp transcribe — say it, and have it written down.
+
+  nixamp transcribe FILE                  the words in a recording
+  nixamp transcribe FILE --say SERVER     and post them to that server's trollbox
+  nixamp transcribe FILE --say SERVER --channel ID   to one channel's room (default: live)
+  nixamp transcribe FILE --language de    when Whisper should not guess
+  nixamp transcribe FILE --json           the answer as JSON
+
+FILE is any recording ffmpeg can read; a WAV needs no ffmpeg at all. The
+hearing is done by nixamp.com with an open-source model (Whisper, through
+Transformers.js) on its own CPU: nothing goes to a speech vendor. It needs a
+sign-in (\`nixamp login\`) and nothing else. Up to a minute at a time.
+
+The same ear is behind the microphone button in every nixamp.com trollbox,
+and behind the transcribe_audio tool of \`nixamp mcp\`.
+`,
+  transcript: `nixamp transcript — what a channel is saying, written down.
+
+  nixamp transcript --channel ID                 the recent lines from this machine's daemon
+  nixamp transcript --url URL --key K --channel ID   from another server, with its share link
+  nixamp transcript ... --follow                 and keep printing as it speaks
+  nixamp transcript ... --json                   the lines as JSON
+
+A server captions a channel while somebody is asking for its transcript: its
+own ffmpeg turns the sound into five-second windows, nixamp.com's ear turns
+those into lines, each stamped with when its sound was heard. The page shows
+them as subtitles, held until its own sound gets there; this prints them.
+The server needs an ffmpeg and a sign-in (\`nixamp login\`).
 `,
   attach: `nixamp attach — the player, in front of the running daemon.
 
@@ -466,6 +501,16 @@ export async function main(): Promise<void> {
     process.exitCode = await party(rest);
     return;
   }
+  if (first === "transcript" || first === "captions") {
+    const { transcript } = await import("./transcript.ts");
+    process.exitCode = await transcript(rest);
+    return;
+  }
+  if (first === "transcribe" || first === "dictate") {
+    const { transcribe } = await import("./transcribe.ts");
+    process.exitCode = await transcribe(rest);
+    return;
+  }
   if (first === "mcp") {
     const { mcp } = await import("./mcp.ts");
     process.exitCode = await mcp();

package/src/mcp.ts

@@ -8,7 +8,9 @@
  *
  * What it offers is the watch party, because that is the part of nixamp an
  * agent can usefully do something with: find the party, say where it is, put
- * one on the air, move everybody to the same second. It signs in as whoever
+ * one on the air, move everybody to the same second. And the room: hear a
+ * recording (nixamp.com's own ear, see speech.ts), say a line in a trollbox,
+ * read one back. It signs in as whoever
  * this machine is signed in as -- the session on disk, or NIXAMP_TOKEN --
  * because an agent holding its own credential is a credential nobody revokes.
  *
@@ -18,6 +20,8 @@
 import { createInterface } from "node:readline";
 import { clock, type PartyRow } from "./party.ts";
 import { readSession } from "./session.ts";
+import { askToHear, wavOf } from "./transcribe.ts";
+import { readTranscript } from "./transcript.ts";
 
 export const PROTOCOL_VERSION = "2025-06-18";
 
@@ -94,12 +98,82 @@ export const TOOLS: ToolDefinition[] = [
     description: "End a watch party. Only its host may.",
     inputSchema: { type: "object", properties: { code: STRING }, required: ["code"] },
   },
+  {
+    name: "transcribe_audio",
+    description:
+      "The words in a recording on this machine, heard by nixamp.com's own open-source ear (Whisper). Any format ffmpeg reads; up to a minute. Given a server, the words are also posted to that server's trollbox as this account.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { ...STRING, description: "The recording's path on this machine." },
+        language: { ...STRING, description: "A two-letter language code, when Whisper should not guess." },
+        server: { ...STRING, description: "Post the words to this nixamp's trollbox: its address, as in its share link." },
+        channel: { ...STRING, description: "Which of that server's channels; its own stream (live) by default." },
+      },
+      required: ["path"],
+    },
+  },
+  {
+    name: "trollbox_say",
+    description:
+      "Say a line in a live room's trollbox, as this account and under its public handle. A room is a nixamp server's address and one of its channels (or `live`, the server's own stream).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: { ...STRING, description: "The nixamp server's address, as in its share link." },
+        channel: { ...STRING, description: "The channel's id, or live (default)." },
+        text: { ...STRING, description: "The line. At most 500 characters." },
+      },
+      required: ["server", "text"],
+    },
+  },
+  {
+    name: "transcript_read",
+    description:
+      "What a live channel is saying: the recent lines of its transcript, oldest first, each with when its sound was heard. The server carrying the channel captions it while somebody asks. Pass the server's address and share key, and the channel's id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { ...STRING, description: "The nixamp server's address, e.g. https://server1.chovy.nixamp.com:4321." },
+        key: { ...STRING, description: "The share key from its link, when it has one." },
+        channel: { ...STRING, description: "The channel's id on that server (default: main)." },
+        after: { type: "number", description: "Only lines heard after this moment (ms since the epoch)." },
+      },
+      required: ["url"],
+    },
+  },
+  {
+    name: "trollbox_read",
+    description: "The recent lines in a live room's trollbox, oldest first: who said what, and when.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        server: { ...STRING, description: "The nixamp server's address, as in its share link." },
+        channel: { ...STRING, description: "The channel's id, or live (default)." },
+        after: { ...STRING, description: "Only lines after this moment (an ISO timestamp)." },
+      },
+      required: ["server"],
+    },
+  },
 ];
 
+interface TrollboxLine {
+  id: string;
+  handle: string;
+  body: string;
+  createdAt: string;
+}
+
+function said(line: TrollboxLine): string {
+  return `${line.createdAt}  ${line.handle}: ${line.body}`;
+}
+
 export interface McpOptions {
   fetcher?: typeof fetch;
   /** Injected by the tests; the session on disk otherwise. */
   session?: { site: string; token: string } | null;
+  /** How a recording becomes a WAV; the tests hand in a fake. */
+  wavOf?: typeof wavOf;
   say?: (line: string) => void;
 }
 
@@ -204,6 +278,75 @@ export async function callTool(name: string, args: Record<string, unknown>, opti
       if (!response.ok) return failed(await answerOf(response));
       return text(`Ended ${code}.`);
     }
+
+    const server = typeof args["server"] === "string" ? args["server"].trim() : "";
+    const channel = typeof args["channel"] === "string" && args["channel"].trim() ? args["channel"].trim() : "live";
+
+    if (name === "transcribe_audio") {
+      const path = typeof args["path"] === "string" ? args["path"] : "";
+      if (!path) return failed("Which recording? Pass its path.");
+      let wav: Uint8Array;
+      try {
+        wav = (options.wavOf ?? wavOf)(path);
+      } catch (error) {
+        return failed((error as Error).message);
+      }
+      const answer = await askToHear(session, {
+        wav,
+        ...(typeof args["language"] === "string" ? { language: args["language"] } : {}),
+        ...(server ? { server, channel } : {}),
+      }, send, site);
+      if (!answer.ok) return failed(answer.error);
+      if (answer.heard.text === "") return text("Heard nothing in that recording.");
+      return text(answer.heard.message
+        ? `${answer.heard.text}\n\nSaid in the room for ${channel} at ${server} as ${answer.heard.message.handle}.`
+        : answer.heard.text);
+    }
+
+    if (name === "trollbox_say") {
+      if (!server) return failed("Which room? Pass the server's address.");
+      const line = typeof args["text"] === "string" ? args["text"] : "";
+      if (!line.trim()) return failed("Say what? Pass the text.");
+      const response = await send(`${site}/api/v1/trollbox`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ server, channel, body: line }),
+      });
+      if (!response.ok) return failed(await answerOf(response));
+      const body = (await response.json()) as { message?: TrollboxLine };
+      return text(body.message ? `Said, as ${body.message.handle}: ${body.message.body}` : "Said.");
+    }
+
+    if (name === "transcript_read") {
+      const url = typeof args["url"] === "string" ? args["url"].trim() : "";
+      if (!url) return failed("Which server? Pass its address.");
+      const got = await readTranscript(
+        { url, key: typeof args["key"] === "string" && args["key"] ? args["key"] : null },
+        channel === "live" ? "main" : channel,
+        typeof args["after"] === "number" ? args["after"] : 0,
+        send,
+      );
+      if (!got.ok) return failed(got.error);
+      if (got.answer.recent.length === 0) {
+        return text(got.answer.error
+          ? `Nothing yet: ${got.answer.error}`
+          : "Nothing said yet. The server has just started listening; ask again in a few seconds.");
+      }
+      return text(got.answer.recent.map((line) => `${new Date(line.at).toISOString()}  ${line.text}`).join("\n"));
+    }
+
+    if (name === "trollbox_read") {
+      if (!server) return failed("Which room? Pass the server's address.");
+      const url = new URL(`${site}/api/v1/trollbox`);
+      url.searchParams.set("server", server);
+      url.searchParams.set("channel", channel);
+      if (typeof args["after"] === "string" && args["after"]) url.searchParams.set("after", args["after"]);
+      const response = await send(url.toString(), { headers });
+      if (!response.ok) return failed(await answerOf(response));
+      const body = (await response.json()) as { messages?: TrollboxLine[] };
+      const lines = body.messages ?? [];
+      return text(lines.length === 0 ? `Nobody has said anything in the room for ${channel} at ${server}.` : lines.map(said).join("\n"));
+    }
   } catch (error) {
     return failed(`Could not reach ${site}: ${(error as Error).message}`);
   }
@@ -219,7 +362,7 @@ export async function handleMessage(message: Request, options: McpOptions = {}):
     return reply({
       protocolVersion: PROTOCOL_VERSION,
       capabilities: { tools: { listChanged: false } },
-      serverInfo: { name: "nixamp", title: "nixamp watch parties", version: "1" },
+      serverInfo: { name: "nixamp", title: "nixamp: watch parties and rooms", version: "1" },
       instructions:
         "Watch parties on nixamp. A party lives on the site hosting the film and is bridged here as a room every nixamp client can join. Codes are the ones that site shows; positions are seconds into the film.",
     });