nixamp 0.23.5 → 0.23.7

package/README.md

@@ -297,6 +297,18 @@ something else.
 Entries expire a few minutes after a stream stops renewing, so the list is
 always what is actually live.
 
+**A live that ends says so.** A film or a podcast that plays to its end, a
+list whose last entry did, or a publisher who stopped, used to start again
+from the top for ever. Now the channel plays its outro: five seconds of
+"THIS LIVE STREAM HAS ENDED" on the plate with the mark (a soft chime, on a
+channel with no picture), looped for an hour, so whoever joins late is told
+by the picture and by the page (an ENDED chip and a line in the Log), and
+the room's trollbox stays open. Then the channel closes on its own. The
+clip is drawn by the server itself with its ffmpeg the first time it is
+needed and kept beside the keys; **Start over** on the channel brings the
+show back from its beginning. A live feed that drops mid-stream is still
+dialled again, as before: only a clean end is an end.
+
 ## The trollbox, and saying a line out loud
 
 Every live room has a trollbox: the chat for whoever has joined that stream,
@@ -314,14 +326,22 @@ which case the words wait in the box for Send. A wrong line is taken down
 with its ✕.
 
 **On the phone, too.** Every live room has a six-digit code on the party
-line (see below), and when anybody is on the phone in a room, each trollbox
-line is read aloud to them: "chovy says: …", in a voice that is theirs as
-far as a machine can manage. The Account panel sets it: a woman's voice, a
-man's, any, or a provider voice id; or an OpenProfile URL, whose `Voice`,
-`Gender` or `Pronouns` decide. Nothing set picks one from the account, so
-the same person is always the same voice. The voices are Telnyx's Kokoro
-ones, open weights, no bill beyond the call; `NIXAMP_VOICE_FEMALE` and
-`NIXAMP_VOICE_MALE` swap in others (an ElevenLabs id, say).
+line (see below), and only when somebody is on the phone in a room, each
+trollbox line is read aloud to them: "chovy says: …", in a voice that is
+theirs as far as a machine can manage, and different from everybody
+else's in the room. The Account panel (or `nixamp profile`, or the
+`profile_set` MCP tool) sets it: a woman's voice, a man's, any, or a voice
+id; or an OpenProfile URL, whose `Voice`, `Gender` or `Pronouns` decide.
+Given a sex, the account picks one voice from that sex's pool and keeps
+it; given nothing, one from the whole pool. `nixamp voices` lists them.
+
+Two pools. Telnyx's Kokoro voices are an open-weights model with no bill
+beyond the call: eleven women, eight men. ElevenLabs reads better and bills
+per character: when the Telnyx account holds an integration secret named
+`elevenlabs` with the ElevenLabs key, nixamp.com finds it on its own and
+uses ElevenLabs' premade voices by their labelled gender; `NIXAMP_TTS=kokoro`
+keeps the free ones regardless. `NIXAMP_VOICES_FEMALE` / `NIXAMP_VOICES_MALE`
+(comma lists of Telnyx voice ids) replace either pool outright.
 The ear is [Whisper](https://github.com/openai/whisper) run through
 [Transformers.js](https://github.com/huggingface/transformers.js), an
 Apache-2.0 library carrying MIT-licensed models, on nixamp.com's own CPU.

package/dist/channels.d.ts

@@ -80,6 +80,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
@@ -136,6 +142,8 @@ export declare const GIVE_UP = 5;
 export declare const STALL = 30000;
 /** How long an on-demand channel stays up with nobody watching. */
 export declare const IDLE = 60000;
+/** How long a channel plays its outro after the show, before it closes. */
+export declare const OUTRO_MS: number;
 /**
  * How much of the recent stream a newcomer is handed. About six seconds of
  * 720p television, and a couple of seconds of 192k MP3: enough to play
@@ -181,6 +189,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. */
@@ -214,6 +232,11 @@ export declare class Channel {
     /** Fires when a pulled source has said nothing for STALL. */
     private watchdog;
     private stall;
+    /** Whether the outro is what is playing now: the show is over. */
+    private outroOn;
+    private outroTimer;
+    /** How the show was dialled, so a restart after the outro is the show again. */
+    private dialed;
     private stderr;
     /**
      * The last few seconds, for whoever joins next.
@@ -259,6 +282,14 @@ export declare class Channel {
      * in it is not a room anybody can be invited to.
      */
     pull(source: string, encode: string[], paced?: boolean, stall?: number, input?: string[], audio?: string, resume?: PullResume): void;
+    /**
+     * 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;
+    private endShow;
     /**
      * Start the source over, now.
      *

package/dist/channels.js

@@ -40,6 +40,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 = {
+    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;
 /**
@@ -140,6 +147,11 @@ export class Channel {
     /** Fires when a pulled source has said nothing for STALL. */
     watchdog = null;
     stall = STALL;
+    /** Whether the outro is what is playing now: the show is over. */
+    outroOn = false;
+    outroTimer = null;
+    /** How the show was dialled, so a restart after the outro is the show again. */
+    dialed = null;
     stderr = "";
     /**
      * The last few seconds, for whoever joins next.
@@ -219,6 +231,8 @@ export class Channel {
      */
     pull(source, encode, paced = true, stall = STALL, input = [], audio = "", resume = { live: true, position: 0 }) {
         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;
@@ -235,9 +249,13 @@ export class Channel {
             this.info.playlistAt = at;
         }
         let current = list ? list[at] : 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];
                 return true;
@@ -267,7 +285,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, [
                 ...prefix,
@@ -362,7 +381,46 @@ 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() {
+        if (this.closing || this.outroOn)
+            return;
+        void this.endShow();
+    }
+    async endShow() {
+        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?.();
     }
     /**
      * Start the source over, now.
@@ -374,8 +432,28 @@ export class Channel {
      * strikes a dead CDN ran up an hour ago.
      */
     restart() {
+        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)
+        if (!dial)
             return false;
         if (this.timer)
             clearTimeout(this.timer);
@@ -469,6 +547,11 @@ export class Channel {
     dropped(sent) {
         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);
@@ -486,6 +569,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;
@@ -786,6 +878,9 @@ export class Channel {
         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;

package/dist/main.js

@@ -62,6 +62,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
@@ -242,7 +244,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.
 
@@ -263,6 +266,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.
 
@@ -473,6 +490,16 @@ export async function main() {
         process.exitCode = await party(rest);
         return;
     }
+    if (first === "profile" || first === "persona") {
+        const { profile } = await import("./profile.js");
+        process.exitCode = await profile(rest);
+        return;
+    }
+    if (first === "voices") {
+        const { voices } = await import("./profile.js");
+        process.exitCode = await voices(rest);
+        return;
+    }
     if (first === "transcript" || first === "captions") {
         const { transcript } = await import("./transcript.js");
         process.exitCode = await transcript(rest);

package/dist/mcp.js

@@ -22,6 +22,7 @@ import { clock } from "./party.js";
 import { readSession } from "./session.js";
 import { askToHear, wavOf } from "./transcribe.js";
 import { readTranscript } from "./transcript.js";
+import { personaLines, readPersona, readVoices, writePersona } from "./profile.js";
 export const PROTOCOL_VERSION = "2025-06-18";
 const STRING = { type: "string" };
 export const TOOLS = [
@@ -119,6 +120,28 @@ export const TOOLS = [
             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.",
@@ -289,6 +312,33 @@ export async function callTool(name, args, options = {}) {
             }
             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 = {};
+            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.");

package/dist/outro.d.ts

@@ -0,0 +1,48 @@
+/** How long the outro plays after a show ends, before the channel closes. */
+export declare const OUTRO_MS: number;
+/** The clip's length; it loops. */
+export declare const OUTRO_SECONDS = 5;
+/** Bumped when the drawing changes, so an old clip on disk is drawn again. */
+export declare const OUTRO_VERSION = 1;
+export interface Rgba {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/** A canvas of straight RGBA bytes. */
+export declare class Bitmap {
+    readonly width: number;
+    readonly height: number;
+    readonly pixels: Uint8Array;
+    constructor(width: number, height: number);
+    fill(color: Rgba): void;
+    rect(x: number, y: number, w: number, h: number, color: Rgba): void;
+    private set;
+}
+/** Encode as a non-interlaced 8-bit RGBA PNG. */
+export declare function encodePng(bitmap: Bitmap): Buffer;
+export declare function textWidth(text: string, cell: number): number;
+export declare function drawText(bitmap: Bitmap, text: string, x: number, y: number, cell: number, color: Rgba): void;
+/** The picture: the mark above the words, on the plate. 1280x720. */
+export declare function drawOutro(width?: number, height?: number): Bitmap;
+/** The encode a channel copies an outro through: what a channel sends on the wire. */
+export declare const OUTRO_ENCODE: Record<"audio" | "video", string[]>;
+export interface OutroOptions {
+    ffmpeg: string[];
+    /** Where the clips are kept. */
+    dir: string;
+    onEvent?: (message: string) => void;
+}
+/**
+ * The clips, drawn on first use and kept. `clip(kind)` answers the path,
+ * or null when there is no ffmpeg to make one, in which case a channel
+ * that ends simply closes as it used to.
+ */
+export declare class Outro {
+    private readonly options;
+    private made;
+    constructor(options: OutroOptions);
+    clip(kind: "audio" | "video"): Promise<string | null>;
+    private make;
+}