nixamp 0.23.5 → 0.23.7

package/dist/voices.d.ts

@@ -1,6 +1,33 @@
 export type VoiceKind = "female" | "male" | "";
-/** Kokoro, through Telnyx: af_heart is the default woman, am_adam the default man. */
+/** Kokoro through Telnyx: American English, the women then the men. Free. */
+export declare const KOKORO_FEMALE: string[];
+export declare const KOKORO_MALE: string[];
+/**
+ * ElevenLabs' premade voices, as `ElevenLabs.<voice id>`, by the gender
+ * ElevenLabs labels them with (read off the account on 2026-09-13). The
+ * names are for whoever reads this file; Telnyx only ever sees the id.
+ */
+export declare const ELEVENLABS_FEMALE: string[];
+export declare const ELEVENLABS_MALE: string[];
+/** Kept for the tests and anybody who wants one voice per sex: the first of each pool. */
 export declare const DEFAULT_VOICES: Record<Exclude<VoiceKind, "">, string>;
+/** The voices to choose among, and what Telnyx needs to speak them. */
+export interface VoicePools {
+    provider: "kokoro" | "elevenlabs" | "custom";
+    female: string[];
+    male: string[];
+    /** Sent as `voice_settings` on an ElevenLabs voice: the integration secret holding the key. */
+    settings?: {
+        api_key_ref: string;
+    };
+}
+/** What a speak command is told: the voice, and the settings that voice needs, if any. */
+export interface SpokenVoice {
+    voice: string;
+    settings?: {
+        api_key_ref: string;
+    };
+}
 /** The word a person used for themselves, as a voice: female, male, or nothing to go on. */
 export declare function voiceKindOf(value: unknown): VoiceKind;
 export interface ProfileVoice {
@@ -16,18 +43,54 @@ export interface ProfileVoice {
  */
 export declare function readProfileVoice(markdown: string): ProfileVoice;
 /**
- * The Telnyx voice for somebody, from what is known about them. A voice
- * named outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used
- * as written; a sex picks the configured voice for it; nothing at all
- * picks one by the account id, so it stays the same tomorrow.
+ * The voice for somebody, from what is known about them. A voice named
+ * outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used as
+ * written; a sex picks from that sex's pool by the account id; nothing at
+ * all picks from both pools the same way, so it stays the same tomorrow.
+ * Settings ride along when the voice is an ElevenLabs one and the pools
+ * know the secret.
  */
 export declare function telnyxVoiceFor(who: {
     userId: string;
     voice?: string;
     profile?: ProfileVoice | null;
-}, voices?: Record<Exclude<VoiceKind, "">, string>): string;
-/** The voices to use per sex, from the environment when it says so. */
+}, pools?: VoicePools | Record<Exclude<VoiceKind, "">, string>): string;
+export declare function spokenVoiceFor(who: {
+    userId: string;
+    voice?: string;
+    profile?: ProfileVoice | null;
+}, pools: VoicePools): SpokenVoice;
+/** The voices to use per sex, from the environment when it says so. Kept for one-voice callers. */
 export declare function voicesFromEnv(env?: NodeJS.ProcessEnv): Record<Exclude<VoiceKind, "">, string>;
+/**
+ * The pools this deployment speaks with. `NIXAMP_VOICES_FEMALE` and
+ * `NIXAMP_VOICES_MALE` (comma lists of Telnyx voice ids) win outright;
+ * `NIXAMP_VOICE_FEMALE` / `NIXAMP_VOICE_MALE` name one voice per sex; else
+ * ElevenLabs when the account holds the secret for it and `NIXAMP_TTS` is
+ * not `kokoro`; else Kokoro, which is free.
+ */
+export declare function poolsFrom(env: NodeJS.ProcessEnv, elevenLabsSecret: string | null): VoicePools;
+/**
+ * Whether Telnyx holds an ElevenLabs key for this account: an integration
+ * secret whose identifier is `elevenlabs` (or what NIXAMP_ELEVENLABS_SECRET
+ * names). Asked once, at the first line, and remembered; no key means the
+ * free voices, and no Railway variable has to be set for either.
+ */
+export declare class Voices {
+    private readonly options;
+    private secret;
+    constructor(options: {
+        telnyxApiKey: string;
+        env?: NodeJS.ProcessEnv;
+        fetcher?: typeof fetch;
+        telnyxApi?: string;
+        onEvent?: (message: string) => void;
+    });
+    private get env();
+    private elevenLabsSecret;
+    /** The pools, resolved once. A failed look at Telnyx is asked again next time. */
+    pools(): Promise<VoicePools>;
+}
 /** What a line sounds like read aloud: who said it, then what. */
 export declare function spokenLine(handle: string, body: string): string;
 /**

package/dist/voices.js

@@ -4,21 +4,60 @@
  * A trollbox line is text; the party line is a phone call. Reading one into
  * the other needs a voice, and the voice should be theirs as far as a
  * machine can manage: a man's line in a man's voice, a woman's in a woman's,
- * anybody else's in whichever they asked for. Where that comes from, in
- * order: the voice they set on their nixamp account; their OpenProfile
+ * and two people in one room in two different voices, so a caller can tell
+ * who is talking without being told every time. Where the sex comes from,
+ * in order: the voice they set on their nixamp account; their OpenProfile
  * (`Voice`, then `Gender`, then `Pronouns`; see logicsrc.com/openprofile);
- * and failing both, one picked from their id, so the same person is always
- * the same voice even when nobody was told which.
+ * and failing both, nothing, in which case they get a voice from the whole
+ * pool. Which voice within the pool is picked from their account id, so the
+ * same person is always the same voice.
  *
- * The voices are Telnyx's Kokoro ones: an open-weights model, no bill beyond
- * the call. ElevenLabs or anything else Telnyx speaks is a configuration
- * away, per sex, because "better" and "paid" are the same word there.
+ * Two pools. Telnyx's Kokoro voices are an open-weights model with no bill
+ * beyond the call: eleven women, eight men, American English. ElevenLabs
+ * reads better and bills per character; Telnyx speaks it when the account
+ * holds an integration secret with the ElevenLabs key, and this file uses
+ * it when that secret exists unless told to stay with Kokoro. Both pools
+ * can be replaced from the environment.
  */
 import { createHash } from "node:crypto";
-/** Kokoro, through Telnyx: af_heart is the default woman, am_adam the default man. */
+/** Kokoro through Telnyx: American English, the women then the men. Free. */
+export const KOKORO_FEMALE = ["af_heart", "af_bella", "af_nicole", "af_sarah", "af_sky", "af_nova", "af_jessica", "af_kore", "af_river", "af_alloy", "af_aoede"]
+    .map((name) => `Telnyx.KokoroTTS.${name}`);
+export const KOKORO_MALE = ["am_adam", "am_michael", "am_echo", "am_eric", "am_fenrir", "am_liam", "am_onyx", "am_puck"]
+    .map((name) => `Telnyx.KokoroTTS.${name}`);
+/**
+ * ElevenLabs' premade voices, as `ElevenLabs.<voice id>`, by the gender
+ * ElevenLabs labels them with (read off the account on 2026-09-13). The
+ * names are for whoever reads this file; Telnyx only ever sees the id.
+ */
+export const ELEVENLABS_FEMALE = [
+    "ElevenLabs.EXAVITQu4vr4xnSDxMaL", // Sarah
+    "ElevenLabs.FGY2WhTYpPnrIDTdsKH5", // Laura
+    "ElevenLabs.Xb7hH8MSUJpSbSDYk0k2", // Alice
+    "ElevenLabs.XrExE9yKIg1WjnnlVkGX", // Matilda
+    "ElevenLabs.cgSgspJ2msm6clMCkdW9", // Jessica
+    "ElevenLabs.hpp4J3VqNfWAUOO0d1Us", // Bella
+    "ElevenLabs.pFZP5JQG7iQjIQuC4Bku", // Lily
+];
+export const ELEVENLABS_MALE = [
+    "ElevenLabs.CwhRBWXzGAHq8TQ4Fs17", // Roger
+    "ElevenLabs.IKne3meq5aSn9XLyUdCD", // Charlie
+    "ElevenLabs.JBFqnCBsd6RMkjVDRZzb", // George
+    "ElevenLabs.N2lVS1w4EtoT3dr4eOWO", // Callum
+    "ElevenLabs.SOYHLrjzK2X1ezoPC6cr", // Harry
+    "ElevenLabs.TX3LPaxmHKxFdv7VOQHJ", // Liam
+    "ElevenLabs.bIHbv24MWmeRgasZH58o", // Will
+    "ElevenLabs.cjVigY5qzO86Huf0OWal", // Eric
+    "ElevenLabs.iP95p4xoKVk53GoZ742B", // Chris
+    "ElevenLabs.nPczCjzI2devNBz1zQrb", // Brian
+    "ElevenLabs.onwK4e9ZLuTAKqWW03F9", // Daniel
+    "ElevenLabs.pNInz6obpgDQGcFmaJgB", // Adam
+    "ElevenLabs.pqHfZKP75CvOlQylNhV4", // Bill
+];
+/** Kept for the tests and anybody who wants one voice per sex: the first of each pool. */
 export const DEFAULT_VOICES = {
-    female: "Telnyx.KokoroTTS.af_heart",
-    male: "Telnyx.KokoroTTS.am_adam",
+    female: KOKORO_FEMALE[0],
+    male: KOKORO_MALE[0],
 };
 /** The word a person used for themselves, as a voice: female, male, or nothing to go on. */
 export function voiceKindOf(value) {
@@ -74,32 +113,122 @@ export function readProfileVoice(markdown) {
     }
     return found;
 }
+/** A stable pick from a list for an id: the same id, the same pick, every time. */
+function pickFor(userId, pool) {
+    const digest = createHash("sha1").update(userId).digest();
+    const index = (digest[0] << 8 | digest[1]) % pool.length;
+    return pool[index];
+}
+/** The pools as one voice per sex, for callers that still think that way. */
+function firstOf(voices) {
+    return { provider: "custom", female: [voices.female], male: [voices.male] };
+}
 /**
- * The Telnyx voice for somebody, from what is known about them. A voice
- * named outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used
- * as written; a sex picks the configured voice for it; nothing at all
- * picks one by the account id, so it stays the same tomorrow.
+ * The voice for somebody, from what is known about them. A voice named
+ * outright (`ElevenLabs.…`, `Telnyx.KokoroTTS.…`, `Polly.…`) is used as
+ * written; a sex picks from that sex's pool by the account id; nothing at
+ * all picks from both pools the same way, so it stays the same tomorrow.
+ * Settings ride along when the voice is an ElevenLabs one and the pools
+ * know the secret.
  */
-export function telnyxVoiceFor(who, voices = DEFAULT_VOICES) {
+export function telnyxVoiceFor(who, pools = { provider: "kokoro", female: KOKORO_FEMALE, male: KOKORO_MALE }) {
+    return spokenVoiceFor(who, "female" in pools && typeof pools.female === "string" ? firstOf(pools) : pools).voice;
+}
+export function spokenVoiceFor(who, pools) {
     const asked = (who.voice ?? "").trim();
-    if (asked.includes("."))
-        return asked;
     const fromProfile = who.profile?.voice.trim() ?? "";
-    if (fromProfile.includes("."))
-        return fromProfile;
-    const kind = voiceKindOf(asked) || voiceKindOf(fromProfile) || voiceKindOf(who.profile?.gender) || voiceKindOf(who.profile?.pronouns);
-    if (kind)
-        return voices[kind];
-    const digit = createHash("sha1").update(who.userId).digest()[0];
-    return digit % 2 === 0 ? voices.female : voices.male;
+    const named = asked.includes(".") ? asked : fromProfile.includes(".") ? fromProfile : "";
+    let voice;
+    if (named) {
+        voice = named;
+    }
+    else {
+        const kind = voiceKindOf(asked) || voiceKindOf(fromProfile) || voiceKindOf(who.profile?.gender) || voiceKindOf(who.profile?.pronouns);
+        const pool = kind === "female" ? pools.female : kind === "male" ? pools.male : [...pools.female, ...pools.male];
+        voice = pool.length > 0 ? pickFor(who.userId, pool) : DEFAULT_VOICES.female;
+    }
+    return voice.startsWith("ElevenLabs.") && pools.settings ? { voice, settings: pools.settings } : { voice };
 }
-/** The voices to use per sex, from the environment when it says so. */
+/** The voices to use per sex, from the environment when it says so. Kept for one-voice callers. */
 export function voicesFromEnv(env = process.env) {
     return {
         female: env["NIXAMP_VOICE_FEMALE"] || DEFAULT_VOICES.female,
         male: env["NIXAMP_VOICE_MALE"] || DEFAULT_VOICES.male,
     };
 }
+function listFrom(value) {
+    return (value ?? "").split(",").map((one) => one.trim()).filter(Boolean);
+}
+/**
+ * The pools this deployment speaks with. `NIXAMP_VOICES_FEMALE` and
+ * `NIXAMP_VOICES_MALE` (comma lists of Telnyx voice ids) win outright;
+ * `NIXAMP_VOICE_FEMALE` / `NIXAMP_VOICE_MALE` name one voice per sex; else
+ * ElevenLabs when the account holds the secret for it and `NIXAMP_TTS` is
+ * not `kokoro`; else Kokoro, which is free.
+ */
+export function poolsFrom(env, elevenLabsSecret) {
+    const female = listFrom(env["NIXAMP_VOICES_FEMALE"]);
+    const male = listFrom(env["NIXAMP_VOICES_MALE"]);
+    const settings = elevenLabsSecret ? { api_key_ref: elevenLabsSecret } : undefined;
+    if (female.length > 0 || male.length > 0) {
+        return { provider: "custom", female: female.length > 0 ? female : KOKORO_FEMALE, male: male.length > 0 ? male : KOKORO_MALE, ...(settings ? { settings } : {}) };
+    }
+    if (env["NIXAMP_VOICE_FEMALE"] || env["NIXAMP_VOICE_MALE"]) {
+        const one = voicesFromEnv(env);
+        return { provider: "custom", female: [one.female], male: [one.male], ...(settings ? { settings } : {}) };
+    }
+    if (settings && (env["NIXAMP_TTS"] ?? "").toLowerCase() !== "kokoro") {
+        return { provider: "elevenlabs", female: ELEVENLABS_FEMALE, male: ELEVENLABS_MALE, settings };
+    }
+    return { provider: "kokoro", female: KOKORO_FEMALE, male: KOKORO_MALE };
+}
+/**
+ * Whether Telnyx holds an ElevenLabs key for this account: an integration
+ * secret whose identifier is `elevenlabs` (or what NIXAMP_ELEVENLABS_SECRET
+ * names). Asked once, at the first line, and remembered; no key means the
+ * free voices, and no Railway variable has to be set for either.
+ */
+export class Voices {
+    options;
+    secret = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get env() {
+        return this.options.env ?? process.env;
+    }
+    async elevenLabsSecret() {
+        const wanted = (this.env["NIXAMP_ELEVENLABS_SECRET"] ?? "elevenlabs").trim();
+        if (!wanted || !this.options.telnyxApiKey)
+            return null;
+        try {
+            const response = await (this.options.fetcher ?? fetch)(`${this.options.telnyxApi ?? "https://api.telnyx.com/v2"}/integration_secrets?page[size]=250`, {
+                headers: { authorization: `Bearer ${this.options.telnyxApiKey}` },
+                signal: AbortSignal.timeout(8000),
+            });
+            if (!response.ok)
+                return null;
+            const body = (await response.json());
+            const found = (body.data ?? []).some((one) => one.identifier === wanted);
+            this.options.onEvent?.(found
+                ? `  voices: ElevenLabs, through Telnyx secret "${wanted}"`
+                : "  voices: Kokoro (no ElevenLabs secret on the Telnyx account)");
+            return found ? wanted : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** The pools, resolved once. A failed look at Telnyx is asked again next time. */
+    async pools() {
+        this.secret ??= this.elevenLabsSecret().then((secret) => {
+            if (secret === null)
+                this.secret = null;
+            return secret;
+        });
+        return poolsFrom(this.env, await this.secret);
+    }
+}
 /** What a line sounds like read aloud: who said it, then what. */
 export function spokenLine(handle, body) {
     const said = body.replace(/\s+/g, " ").trim();

package/package.json

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

package/src/channels.ts

@@ -95,6 +95,12 @@ export interface ChannelInfo {
    * plain URL is read this way, and only when a policy asks for it.
    */
   teed?: boolean;
+  /**
+   * When its show ended, wall clock, while the outro plays. A channel with
+   * this set is still on the air -- the picture says the stream has ended
+   * -- and closes on its own an hour later. Absent while the show is on.
+   */
+  ended?: number;
   /**
    * A picture of it from somewhere else: the thumbnail the site offered
    * for a pasted link, the logo a catalog gave a channel. A channel with
@@ -156,6 +162,13 @@ export const GIVE_UP = 5;
 export const STALL = 30_000;
 /** How long an on-demand channel stays up with nobody watching. */
 export const IDLE = 60_000;
+/** How long a channel plays its outro after the show, before it closes. */
+export const OUTRO_MS = 60 * 60 * 1000;
+/** The encode the outro is copied through: what a channel sends on the wire. */
+const OUTRO_ENCODE: Record<"audio" | "video", string[]> = {
+  video: ["-c", "copy", "-f", "mp4", "-movflags", "frag_keyframe+empty_moov+default_base_moof"],
+  audio: ["-c", "copy", "-f", "mp3"],
+};
 /** How much of what ffmpeg said to keep, for the last line when it dies. */
 const TAIL = 2000;
 /**
@@ -241,6 +254,16 @@ export interface ChannelOptions {
   ffmpeg: string[];
   onStart?: (info: ChannelInfo) => void;
   onEnd?: (info: ChannelInfo) => void;
+  /**
+   * The outro: the clip a channel plays once its show is over, by kind,
+   * encoded as the wire wants it (see outro.ts). Null, or absent, means a
+   * show that ends closes its channel as it always did.
+   */
+  outro?: (kind: "audio" | "video") => Promise<string | null>;
+  /** How long the outro plays before the channel closes. An hour. */
+  outroMs?: number;
+  /** Said once, when a show ends and the outro begins. */
+  onOutro?: (info: ChannelInfo) => void;
   /** How long an on-demand channel outlives its last viewer. Tests shorten it. */
   idleMs?: number;
   /** Unsent bytes a listener may hold before it is dropped. Tests shrink it. */
@@ -272,6 +295,11 @@ export class Channel {
   /** Fires when a pulled source has said nothing for STALL. */
   private watchdog: ReturnType<typeof setTimeout> | null = null;
   private stall = STALL;
+  /** Whether the outro is what is playing now: the show is over. */
+  private outroOn = false;
+  private outroTimer: ReturnType<typeof setTimeout> | null = null;
+  /** How the show was dialled, so a restart after the outro is the show again. */
+  private dialed: { source: string; encode: string[]; paced: boolean; stall: number; input: string[]; audio: string; resume: PullResume } | null = null;
   private stderr = "";
   /**
    * The last few seconds, for whoever joins next.
@@ -368,6 +396,7 @@ export class Channel {
     resume: PullResume = { live: true, position: 0 },
   ): void {
     this.stall = stall;
+    if (!this.outroOn) this.dialed = { source, encode, paced, stall, input: [...input], audio, resume };
     if (this.info.kind === "video") this.fragments = new Fragments();
     const [command, ...prefix] = this.options.ffmpeg as [string, ...string[]];
     this.info.live = resume.live;
@@ -382,9 +411,12 @@ export class Channel {
       this.info.playlistAt = at;
     }
     let current = list ? (list[at] as string) : source;
+    // The last entry is the end of the show, not a way back to the first:
+    // a list that played through is over, and says so with the outro.
     this.advance = list && list.length > 1
       ? () => {
-          at = (at + 1) % list.length;
+          if (at + 1 >= list.length) return false;
+          at += 1;
           this.info.playlistAt = at;
           current = list[at] as string;
           return true;
@@ -414,7 +446,8 @@ export class Channel {
       // policy set after the channel started applies at its next restart.
       this.throughAbort?.abort();
       this.throughAbort = null;
-      const through = this.options.through?.(this.info, from, input, audio) ?? null;
+      // The outro is a file read by ffmpeg itself: a pipe cannot loop.
+      const through = this.outroOn ? null : this.options.through?.(this.info, from, input, audio) ?? null;
       this.info.teed = through !== null;
       const child = spawn(
         command,
@@ -509,7 +542,43 @@ export class Channel {
 
     this.redial = dial;
     dial();
-    this.options.onStart?.(this.info);
+    if (!this.outroOn) this.options.onStart?.(this.info);
+  }
+
+  /**
+   * The show is over: the outro, then the end. A publisher's channel is
+   * told this when the publisher goes, so whoever joins in the next hour
+   * is shown that the stream has ended rather than nothing at all. Without
+   * an outro to play it is the same as close().
+   */
+  finish(): void {
+    if (this.closing || this.outroOn) return;
+    void this.endShow();
+  }
+
+  private async endShow(): Promise<void> {
+    const kind = this.info.kind ?? "audio";
+    const old = this.child;
+    this.child = null;
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+    old?.kill("SIGKILL");
+    const clip = this.options.outro ? await this.options.outro(kind).catch(() => null) : null;
+    if (this.closing) return;
+    if (!clip) {
+      this.close();
+      return;
+    }
+    this.outroOn = true;
+    this.info.ended = Date.now();
+    this.info.error = undefined;
+    this.startOver();
+    this.options.onOutro?.(this.info);
+    this.pull(clip, OUTRO_ENCODE[kind], true, this.stall, ["-stream_loop", "-1"], "", { live: true, position: 0 });
+    this.outroTimer = setTimeout(() => this.close(), this.options.outroMs ?? OUTRO_MS);
+    this.outroTimer.unref?.();
   }
 
   /**
@@ -522,8 +591,26 @@ export class Channel {
    * strikes a dead CDN ran up an hour ago.
    */
   restart(): boolean {
+    if (this.closing) return false;
+    // Started over from the outro: the show itself, from its beginning.
+    if (this.outroOn && this.dialed) {
+      this.outroOn = false;
+      delete this.info.ended;
+      if (this.outroTimer) clearTimeout(this.outroTimer);
+      this.outroTimer = null;
+      const old = this.child;
+      this.child = null;
+      old?.kill("SIGKILL");
+      this.failures = 0;
+      this.info.error = undefined;
+      this.info.playlistAt = 0;
+      this.startOver();
+      const show = this.dialed;
+      this.pull(show.source, show.encode, show.paced, show.stall, show.input, show.audio, { ...show.resume, position: 0 });
+      return true;
+    }
     const dial = this.redial;
-    if (!dial || this.closing) return false;
+    if (!dial) return false;
     if (this.timer) clearTimeout(this.timer);
     this.timer = null;
     if (this.watchdog) clearTimeout(this.watchdog);
@@ -613,6 +700,11 @@ export class Channel {
    */
   private dropped(sent: boolean): void {
     if (this.closing || !this.redial) return;
+    // An outro that stopped is over; there is nothing after it.
+    if (this.outroOn) {
+      this.close();
+      return;
+    }
     this.child = null;
     if (this.watchdog) clearTimeout(this.watchdog);
     this.watchdog = null;
@@ -628,6 +720,15 @@ export class Channel {
     // gave nothing is skipped the same way, counted as the failure it was,
     // so a list of dead links gives up rather than cycling for ever.
     const moved = this.advance?.() ?? false;
+    // A show that ended: a film or a podcast that played to its end, a
+    // list whose last entry did. That is not a source that dropped, and it
+    // is not dialled again from the top; it is over, and the outro says
+    // so. A live feed that stopped is a feed that dropped, and is redialled.
+    const list = (this.info.playlist?.length ?? 0) > 0;
+    if (sent && !moved && (this.info.live === false || list)) {
+      void this.endShow();
+      return;
+    }
     const ended = moved && sent;
     if (ended) this.info.error = undefined;
     else this.info.redials = (this.info.redials ?? 0) + 1;
@@ -914,6 +1015,8 @@ export class Channel {
     this.watchdog = null;
     if (this.idle) clearTimeout(this.idle);
     this.idle = null;
+    if (this.outroTimer) clearTimeout(this.outroTimer);
+    this.outroTimer = null;
     const said = lastLine(this.stderr);
     if (said && !this.info.error) this.info.error = said;
     const child = this.child;

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`);