nixamp 0.23.4 → 0.23.6

package/src/main.ts

@@ -86,6 +86,8 @@ const HELP = `nixamp — it really whips the terminal's ass.
   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 profile [--handle H] [--voice V] [--profile URL]  who the rooms know you as
+  nixamp voices                  the voices a line is read in on the phone
   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
@@ -268,7 +270,8 @@ It offers the watch party tools: list them, read one, put one on the air,
 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
+channel is saying (transcript_read), and who you are in the rooms and how
+you sound on the phone (profile_get, profile_set, voices_list). It acts as
 whoever this machine is signed in as, so \`nixamp login\` (or NIXAMP_TOKEN)
 comes first.
 
@@ -289,6 +292,20 @@ 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\`.
+`,
+  profile: `nixamp profile — who the rooms know you as.
+
+  nixamp profile                       your handle, voice and OpenProfile
+  nixamp profile --handle chovy        the name on every line you say
+  nixamp profile --voice female        the voice your lines are read in on the phone:
+                                       female, male, any, or a voice id (see \`nixamp voices\`)
+  nixamp profile --profile URL         your OpenProfile.md; its Voice, Gender or Pronouns
+                                       decide the voice when you set none here
+  nixamp voices                        the voices this nixamp.com reads lines in
+
+When somebody is on the phone in a live room, every trollbox line is read to
+them in the author's voice: the one set here, else the OpenProfile's, else
+one picked for the account and kept. Two people in a room are two voices.
 `,
   transcript: `nixamp transcript — what a channel is saying, written down.
 
@@ -502,6 +519,16 @@ export async function main(): Promise<void> {
     process.exitCode = await party(rest);
     return;
   }
+  if (first === "profile" || first === "persona") {
+    const { profile } = await import("./profile.ts");
+    process.exitCode = await profile(rest);
+    return;
+  }
+  if (first === "voices") {
+    const { voices } = await import("./profile.ts");
+    process.exitCode = await voices(rest);
+    return;
+  }
   if (first === "transcript" || first === "captions") {
     const { transcript } = await import("./transcript.ts");
     process.exitCode = await transcript(rest);

package/src/mcp.ts

@@ -22,6 +22,7 @@ import { clock, type PartyRow } from "./party.ts";
 import { readSession } from "./session.ts";
 import { askToHear, wavOf } from "./transcribe.ts";
 import { readTranscript } from "./transcript.ts";
+import { personaLines, readPersona, readVoices, writePersona } from "./profile.ts";
 
 export const PROTOCOL_VERSION = "2025-06-18";
 
@@ -142,6 +143,29 @@ export const TOOLS: ToolDefinition[] = [
       required: ["url"],
     },
   },
+  {
+    name: "profile_get",
+    description: "Who the rooms know this account as: its handle, the voice its trollbox lines are read in on the phone, the OpenProfile URL, and the voice that would be used right now.",
+    inputSchema: { type: "object", properties: {} },
+  },
+  {
+    name: "profile_set",
+    description:
+      "Set this account's handle, the voice its lines are read in on the phone (female, male, any, or a voice id from voices_list), and/or its OpenProfile URL (whose Voice, Gender or Pronouns pick the voice when none is set). Any one may be given alone.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        handle: { ...STRING, description: "Letters, digits and hyphens, 2 to 30 characters." },
+        voice: { ...STRING, description: "female, male, any, or a voice id such as ElevenLabs.pNInz6obpgDQGcFmaJgB." },
+        profile: { ...STRING, description: "The URL of an OpenProfile.md, or an empty string to clear it." },
+      },
+    },
+  },
+  {
+    name: "voices_list",
+    description: "The voices trollbox lines can be read in on the phone: the provider in use and the women's and men's voice ids.",
+    inputSchema: { type: "object", properties: {} },
+  },
   {
     name: "trollbox_read",
     description: "The recent lines in a live room's trollbox, oldest first: who said what, and when.",
@@ -335,6 +359,29 @@ export async function callTool(name: string, args: Record<string, unknown>, opti
       return text(got.answer.recent.map((line) => `${new Date(line.at).toISOString()}  ${line.text}`).join("\n"));
     }
 
+    if (name === "profile_get") {
+      const answer = await readPersona(session, send);
+      if (!answer.ok) return failed(answer.error);
+      return text(personaLines(answer.body).join("\n"));
+    }
+
+    if (name === "profile_set") {
+      const wanted: { handle?: string; voice?: string; profile?: string } = {};
+      if (typeof args["handle"] === "string") wanted.handle = args["handle"];
+      if (typeof args["voice"] === "string") wanted.voice = args["voice"];
+      if (typeof args["profile"] === "string") wanted.profile = args["profile"];
+      if (Object.keys(wanted).length === 0) return failed("Set what? Pass handle, voice and/or profile.");
+      const answer = await writePersona(session, wanted, send);
+      if (!answer.ok) return failed(answer.error);
+      return text(personaLines(answer.body).join("\n"));
+    }
+
+    if (name === "voices_list") {
+      const answer = await readVoices(session, send);
+      if (!answer.ok) return failed(answer.error);
+      return text([`Voices: ${answer.body.provider}.`, "Women:", ...answer.body.female.map((one) => `  ${one}`), "Men:", ...answer.body.male.map((one) => `  ${one}`)].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`);

package/src/partyline.ts

@@ -702,6 +702,32 @@ export class PartyLine {
     });
   }
 
+  /**
+   * A line said into a room, to everybody on the phone in it. What the
+   * trollbox becomes on the party line: the handle and the words, in the
+   * voice of whoever typed them. False when nobody is on the phone there,
+   * which is most of the time and costs nothing.
+   */
+  async say(code: string, text: string, voice: string, settings?: { api_key_ref: string }): Promise<boolean> {
+    const room = this.rooms.get(code);
+    if (!room || room.conferenceId === null || room.callers === 0) return false;
+    const said = text.replace(/\s+/g, " ").trim().slice(0, 500);
+    if (said === "") return false;
+    const answer = await this.request(`/conferences/${encodeURIComponent(room.conferenceId)}/actions/speak`, {
+      payload: said,
+      voice: voice || this.voice,
+      // An ElevenLabs voice needs the key Telnyx holds for it, by name.
+      ...(settings ? { voice_settings: settings } : {}),
+    });
+    return answer !== null;
+  }
+
+  /** Whether anybody is on the phone in a room, before a line is worth reading. */
+  hasCallers(code: string): boolean {
+    const room = this.rooms.get(code);
+    return room !== undefined && room.conferenceId !== null && room.callers > 0;
+  }
+
   /**
    * How many people are on the phone for a stream.
    *

package/src/profile.ts

@@ -0,0 +1,174 @@
+/**
+ * `nixamp profile` and `nixamp voices` -- who the rooms know you as, from
+ * the terminal, and the voices a line can be read in.
+ *
+ * The same route the Account panel uses (`/api/v1/me/handle`), signed in
+ * as this machine is. The MCP tools of the same names are these functions
+ * with a different front.
+ */
+import { readSession, type Session } from "./session.ts";
+
+const HELP = `nixamp profile — who the rooms know you as.
+
+  nixamp profile                       your handle, voice and OpenProfile
+  nixamp profile --handle chovy        the name on every line you say
+  nixamp profile --voice female        the voice your lines are read in on the phone:
+                                       female, male, any, or a voice id (see \`nixamp voices\`)
+  nixamp profile --profile URL         your OpenProfile.md; its Voice, Gender or Pronouns
+                                       decide the voice when you set none here
+  nixamp profile --json                as JSON
+  nixamp voices                        the voices this nixamp.com reads lines in
+
+When somebody is on the phone in a live room, every trollbox line is read
+to them in the author's voice: the one set here, else the OpenProfile's,
+else one picked for the account and kept. Two people in a room are two
+different voices.
+`;
+
+export interface Persona {
+  handle: string;
+  voice: string;
+  profile: string;
+  chosen: boolean;
+  /** The voice a line of theirs would be read in right now. */
+  spoken?: string;
+}
+
+export interface Pools {
+  provider: string;
+  female: string[];
+  male: string[];
+}
+
+export type Answer<T> = { ok: true; body: T } | { ok: false; status: number; error: string };
+
+function headers(session: Pick<Session, "token">): Record<string, string> {
+  return { authorization: `Bearer ${session.token}`, "content-type": "application/json" };
+}
+
+export async function readPersona(session: Pick<Session, "site" | "token">, fetcher: typeof fetch = fetch): Promise<Answer<Persona>> {
+  try {
+    const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, { headers: headers(session) });
+    const body = (await response.json().catch(() => ({}))) as Persona & { error?: string };
+    if (!response.ok) return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+    return { ok: true, body };
+  } catch (error) {
+    return { ok: false, status: 0, error: `could not reach ${session.site}: ${(error as Error).message}` };
+  }
+}
+
+export async function writePersona(
+  session: Pick<Session, "site" | "token">,
+  wanted: { handle?: string; voice?: string; profile?: string },
+  fetcher: typeof fetch = fetch,
+): Promise<Answer<Persona>> {
+  try {
+    const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/me/handle`, {
+      method: "PUT",
+      headers: headers(session),
+      body: JSON.stringify(wanted),
+    });
+    const body = (await response.json().catch(() => ({}))) as Persona & { error?: string };
+    if (!response.ok) return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+    return { ok: true, body };
+  } catch (error) {
+    return { ok: false, status: 0, error: `could not reach ${session.site}: ${(error as Error).message}` };
+  }
+}
+
+export async function readVoices(session: Pick<Session, "site" | "token">, fetcher: typeof fetch = fetch): Promise<Answer<Pools>> {
+  try {
+    const response = await fetcher(`${session.site.replace(/\/+$/, "")}/api/v1/voices`, { headers: headers(session) });
+    const body = (await response.json().catch(() => ({}))) as Pools & { error?: string };
+    if (!response.ok) return { ok: false, status: response.status, error: body.error ?? `nixamp answered ${response.status}` };
+    return { ok: true, body };
+  } catch (error) {
+    return { ok: false, status: 0, error: `could not reach ${session.site}: ${(error as Error).message}` };
+  }
+}
+
+/** A persona, as the terminal says it. */
+export function personaLines(persona: Persona): string[] {
+  const voice = persona.voice === "female" ? "a woman's voice"
+    : persona.voice === "male" ? "a man's voice"
+      : persona.voice ? `the voice ${persona.voice}`
+        : persona.profile ? "whatever your OpenProfile says, else one picked for you"
+          : "one picked for you";
+  return [
+    persona.chosen ? `You are ${persona.handle} in every room.` : `Rooms call you ${persona.handle} until you pick a handle (--handle).`,
+    `On the phone your lines are read in ${voice}${persona.spoken ? ` (${persona.spoken})` : ""}.`,
+    persona.profile ? `OpenProfile: ${persona.profile}` : "No OpenProfile set (--profile URL).",
+  ];
+}
+
+function flag(argv: string[], name: string): string | undefined {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+}
+
+export interface ProfileDeps {
+  fetcher?: typeof fetch;
+  session?: Pick<Session, "site" | "token"> | null;
+}
+
+export async function profile(argv: string[], deps: ProfileDeps = {}): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h") || argv[0] === "help") {
+    console.log(HELP);
+    return 0;
+  }
+  const session = deps.session === undefined ? readSession() : deps.session;
+  if (session === null) {
+    console.error("nixamp: not signed in. Try `nixamp login`.");
+    return 1;
+  }
+  const fetcher = deps.fetcher ?? fetch;
+  const wanted: { handle?: string; voice?: string; profile?: string } = {};
+  for (const [name, key] of [["--handle", "handle"], ["--voice", "voice"], ["--profile", "profile"]] as const) {
+    if (argv.includes(name)) {
+      const value = flag(argv, name);
+      if (value === undefined || value.startsWith("--")) {
+        console.error(`nixamp: ${name} needs a value.`);
+        return 64;
+      }
+      wanted[key] = value;
+    }
+  }
+  const answer = Object.keys(wanted).length > 0 ? await writePersona(session, wanted, fetcher) : await readPersona(session, fetcher);
+  if (!answer.ok) {
+    console.error(`nixamp: ${answer.error}`);
+    return 1;
+  }
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(answer.body, null, 2));
+    return 0;
+  }
+  for (const line of personaLines(answer.body)) console.log(line);
+  return 0;
+}
+
+export async function voices(argv: string[], deps: ProfileDeps = {}): Promise<number> {
+  if (argv.includes("--help") || argv.includes("-h")) {
+    console.log(HELP);
+    return 0;
+  }
+  const session = deps.session === undefined ? readSession() : deps.session;
+  if (session === null) {
+    console.error("nixamp: not signed in. Try `nixamp login`.");
+    return 1;
+  }
+  const answer = await readVoices(session, deps.fetcher ?? fetch);
+  if (!answer.ok) {
+    console.error(`nixamp: ${answer.error}`);
+    return 1;
+  }
+  if (argv.includes("--json")) {
+    console.log(JSON.stringify(answer.body, null, 2));
+    return 0;
+  }
+  console.log(`Voices: ${answer.body.provider}. Set one with \`nixamp profile --voice <id>\`, or --voice female/male to be given one of these and keep it.`);
+  console.log("  Women:");
+  for (const one of answer.body.female) console.log(`    ${one}`);
+  console.log("  Men:");
+  for (const one of answer.body.male) console.log(`    ${one}`);
+  return 0;
+}

package/src/server.ts

@@ -88,6 +88,7 @@ import { Rooms } from "./rooms.ts";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.ts";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.ts";
 import { Captions } from "./captions.ts";
+import { Profiles, Voices, spokenLine, spokenVoiceFor } from "./voices.ts";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.ts";
 import {
   applyRemoteConfig,
@@ -1733,6 +1734,10 @@ export interface HandlerOptions {
   trollbox?: Trollbox;
   /** Speech to text: a line said out loud, heard here. Needs the optional model. */
   speech?: Speech;
+  /** Other people's OpenProfiles, for the voice their lines are read in. */
+  profiles?: Profiles;
+  /** The voices lines are read in: ElevenLabs when Telnyx holds the key, Kokoro otherwise. */
+  voices?: Voices;
   /** Tickets: a paid pass to one event's room. Absent means every show is free. */
   tickets?: Tickets;
   /**
@@ -2703,6 +2708,50 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     // Separate from the address on purpose. The address is a credential and
     // a way to reach somebody; publishing it in a directory listing or an
     // invite would be publishing what they log in with.
+    /**
+     * A trollbox line, read aloud to whoever is on the phone in that room.
+     * The room's code comes from the directory (one per channel, one for
+     * the server's own stream), the voice from the author's account or
+     * OpenProfile. Never awaited by the poster: the phone is a side effect
+     * of the chat, and a slow Telnyx must not slow the box.
+     */
+    const readOnThePhone = (where: { server: string; channel: string }, authorId: string, handle: string, body: string): void => {
+      const partyLine = options.partyLine;
+      const listing = (options.directory?.list() ?? []).find((one) => {
+        try {
+          return new URL(one.url).origin === where.server;
+        } catch {
+          return false;
+        }
+      });
+      if (!partyLine || !listing) return;
+      const code = where.channel === "live" || where.channel === "main" ? listing.code : listing.channelCodes[where.channel] ?? "";
+      if (!code || !partyLine.hasCallers(code)) return;
+      void (async () => {
+        const persona = (await options.handles?.persona(authorId)) ?? { handle, voice: "", profile: "" };
+        const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
+        const pools = options.voices ? await options.voices.pools() : { provider: "kokoro" as const, female: [], male: [] };
+        const spoken = spokenVoiceFor({ userId: authorId, voice: persona.voice, profile }, pools);
+        await partyLine.say(code, spokenLine(handle, body), spoken.voice, spoken.settings);
+      })().catch(() => undefined);
+    };
+
+    /*
+     * The voices a line can be read in, for whoever wants to pick one by
+     * id: which provider, and the women's and the men's pools. Signed in,
+     * like the profile it feeds.
+     */
+    if (path === "/api/v1/voices" && options.accounts) {
+      const who = await options.accounts.whoIs(tokenFrom(request.headers));
+      if (who === null) {
+        json(response, 401, { error: "not signed in" });
+        return;
+      }
+      const pools = options.voices ? await options.voices.pools() : { provider: "kokoro" as const, female: [], male: [] };
+      json(response, 200, { provider: pools.provider, female: pools.female, male: pools.male });
+      return;
+    }
+
     /*
      * The trollbox: the chat for one live room, keyed by the server and
      * the channel so every viewer of a stream is in the same box whichever
@@ -2751,6 +2800,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
           }
           const handle = (await options.handles?.of(who.id)) || fallbackHandle(who.id);
           const line = await trollbox.post(where, who.id, handle, body.body);
+          readOnThePhone(where, who.id, line.handle, line.body);
           json(response, 201, { message: { id: line.id, handle: line.handle, body: line.body, createdAt: line.createdAt, mine: true } });
           return;
         }
@@ -2819,6 +2869,7 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         if (where && options.trollbox && heard.text !== "") {
           const handle = (await options.handles?.of(who.id)) || fallbackHandle(who.id);
           const line = await options.trollbox.post(where, who.id, handle, heard.text);
+          readOnThePhone(where, who.id, line.handle, line.body);
           json(response, 201, {
             text: heard.text, seconds: heard.seconds, model: speech.model,
             message: { id: line.id, handle: line.handle, body: line.body, createdAt: line.createdAt, mine: true },
@@ -2841,24 +2892,43 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         return;
       }
 
+      // The handle, and since 0.23.4 the voice a line is read in on the
+      // phone and the OpenProfile it may be read from. Any of the three may
+      // be sent alone; what is not sent is kept.
       if (request.method === "GET") {
-        json(response, 200, { handle: await handles.of(who.id) });
+        const persona = await handles.persona(who.id);
+        // And the voice a line of theirs would be read in right now, so the
+        // panel and the CLI can say it rather than describe the rule.
+        const pools = options.voices ? await options.voices.pools() : null;
+        const profile = persona.profile && options.profiles ? await options.profiles.voiceOf(persona.profile) : null;
+        const spoken = pools ? spokenVoiceFor({ userId: who.id, voice: persona.voice, profile }, pools).voice : "";
+        json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "", spoken });
         return;
       }
       if (request.method === "PUT" || request.method === "POST") {
-        let body: { handle?: unknown };
+        let body: { handle?: unknown; voice?: unknown; profile?: unknown };
         try {
           body = JSON.parse(await readBody(request)) as typeof body;
         } catch {
           json(response, 400, { error: "bad JSON" });
           return;
         }
-        const claimed = await handles.claim(who.id, body.handle);
-        if (claimed.error) {
-          json(response, 409, { error: claimed.error });
-          return;
+        if (body.handle !== undefined) {
+          const claimed = await handles.claim(who.id, body.handle);
+          if (claimed.error) {
+            json(response, 409, { error: claimed.error });
+            return;
+          }
         }
-        json(response, 200, { handle: claimed.handle });
+        if (body.voice !== undefined || body.profile !== undefined) {
+          const described = await handles.describe(who.id, fallbackHandle(who.id), { voice: body.voice, profile: body.profile });
+          if (described.error) {
+            json(response, 422, { error: described.error });
+            return;
+          }
+        }
+        const persona = await handles.persona(who.id);
+        json(response, 200, { ...persona, handle: persona.handle || fallbackHandle(who.id), chosen: persona.handle !== "" });
         return;
       }
       json(response, 405, { error: "GET or PUT" });
@@ -5824,6 +5894,14 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     ...(rooms ? { rooms } : {}),
     ...(trollbox ? { trollbox } : {}),
     ...(speech ? { speech } : {}),
+    // Other people's OpenProfiles, read for the voice a line is spoken in,
+    // and the voices to speak in: ElevenLabs when the Telnyx account holds
+    // the key for it (an integration secret named "elevenlabs"), Kokoro
+    // otherwise. Nothing to configure on the deployment for either.
+    ...(accounts ? { profiles: new Profiles() } : {}),
+    ...(accounts && process.env["TELNYX_API_KEY"]
+      ? { voices: new Voices({ telnyxApiKey: process.env["TELNYX_API_KEY"], onEvent: (message) => console.log(message) }) }
+      : {}),
     ...(tickets ? { tickets } : {}),
     ...(authServer ? { authServer } : {}),
     ...(parties ? { parties } : {}),