nixamp 0.23.4 → 0.23.6

package/dist/server.js

@@ -67,6 +67,7 @@ import { Rooms } from "./rooms.js";
 import { Trollbox, TrollboxError, fallbackHandle, roomFor } from "./trollbox.js";
 import { MAX_BYTES as SPEECH_BYTES, Speech, SpeechError, isWav, languageOf } from "./speech.js";
 import { Captions } from "./captions.js";
+import { Profiles, Voices, spokenLine, spokenVoiceFor } from "./voices.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
 import { isRemote, isTransportStream, playsInBrowser, sourceLabel } from "./sources.js";
@@ -2186,6 +2187,51 @@ export function createHandler(engine, options) {
         // 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, authorId, handle, body) => {
+            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", 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", 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
@@ -2235,6 +2281,7 @@ export function createHandler(engine, options) {
                     }
                     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;
                 }
@@ -2306,6 +2353,7 @@ export function createHandler(engine, options) {
                 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 },
@@ -2329,8 +2377,17 @@ export function createHandler(engine, options) {
                 json(response, 401, { error: "not signed in" });
                 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") {
@@ -2342,12 +2399,22 @@ export function createHandler(engine, options) {
                     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;
+                    }
+                }
+                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;
+                    }
                 }
-                json(response, 200, { handle: claimed.handle });
+                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" });
@@ -5178,6 +5245,14 @@ export async function serve(argv, version = "0.1.0") {
         ...(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 } : {}),

package/dist/voices.d.ts

@@ -0,0 +1,107 @@
+export type VoiceKind = "female" | "male" | "";
+/** 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 {
+    /** What the profile said outright, when it did: female, male, or a provider voice id. */
+    voice: string;
+    gender: string;
+    pronouns: string;
+}
+/**
+ * The parts of an OpenProfile.md that say how somebody sounds. The identity
+ * block is the bullets under the first `#`; `Gender` may also sit under
+ * `## Match`, where the spec put it first. Everything else is ignored.
+ */
+export declare function readProfileVoice(markdown: string): ProfileVoice;
+/**
+ * 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;
+}, 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;
+/**
+ * Somebody's OpenProfile, fetched and kept an hour. A profile is read on
+ * every line they say, and a line a second is the trollbox's own limit.
+ */
+export declare class Profiles {
+    private readonly fetcher;
+    private readonly now;
+    private readonly ttlMs;
+    private readonly kept;
+    constructor(fetcher?: typeof fetch, now?: () => number, ttlMs?: number);
+    voiceOf(url: string): Promise<ProfileVoice | null>;
+}

package/dist/voices.js

@@ -0,0 +1,285 @@
+/**
+ * The voice a person's words are read in, on the phone.
+ *
+ * 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,
+ * 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, 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.
+ *
+ * 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: 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: 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) {
+    if (typeof value !== "string")
+        return "";
+    const word = value.trim().toLowerCase();
+    if (word === "")
+        return "";
+    if (/^(f|female|woman|women|girl|she|her|she\/her|fem|feminine|lady)$/.test(word))
+        return "female";
+    if (/^(m|male|man|men|boy|he|him|he\/him|masc|masculine|guy)$/.test(word))
+        return "male";
+    if (/^she\b/.test(word))
+        return "female";
+    if (/^he\b/.test(word))
+        return "male";
+    return "";
+}
+/**
+ * The parts of an OpenProfile.md that say how somebody sounds. The identity
+ * block is the bullets under the first `#`; `Gender` may also sit under
+ * `## Match`, where the spec put it first. Everything else is ignored.
+ */
+export function readProfileVoice(markdown) {
+    const found = { voice: "", gender: "", pronouns: "" };
+    let section = "";
+    let started = false;
+    for (const raw of markdown.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith("# ") && !started) {
+            started = true;
+            continue;
+        }
+        if (line.startsWith("## ")) {
+            section = line.slice(3).trim().toLowerCase();
+            continue;
+        }
+        const inIdentity = started && section === "";
+        const inMatch = /^(match|dating|matching|partner|looking for)$/.test(section);
+        if (!inIdentity && !inMatch)
+            continue;
+        const item = /^[-*]\s+(?:\*\*)?([A-Za-z ]+?)(?:\*\*)?\s*:\s*(.+)$/.exec(line);
+        if (!item)
+            continue;
+        const key = (item[1] ?? "").trim().toLowerCase();
+        const value = (item[2] ?? "").trim();
+        if (key === "voice" && !found.voice)
+            found.voice = value;
+        if (key === "gender" && !found.gender)
+            found.gender = value;
+        if (key === "pronouns" && !found.pronouns)
+            found.pronouns = value;
+    }
+    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 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, 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();
+    const fromProfile = who.profile?.voice.trim() ?? "";
+    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. 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();
+    return `${handle.replace(/-/g, " ")} says: ${said}`;
+}
+/**
+ * Somebody's OpenProfile, fetched and kept an hour. A profile is read on
+ * every line they say, and a line a second is the trollbox's own limit.
+ */
+export class Profiles {
+    fetcher;
+    now;
+    ttlMs;
+    kept = new Map();
+    constructor(fetcher = fetch, now = () => Date.now(), ttlMs = 60 * 60 * 1000) {
+        this.fetcher = fetcher;
+        this.now = now;
+        this.ttlMs = ttlMs;
+    }
+    async voiceOf(url) {
+        let where;
+        try {
+            where = new URL(url);
+            if (where.protocol !== "https:" && where.protocol !== "http:")
+                return null;
+        }
+        catch {
+            return null;
+        }
+        const had = this.kept.get(where.href);
+        if (had && this.now() - had.at < this.ttlMs)
+            return had.voice;
+        try {
+            const response = await this.fetcher(where.href, {
+                headers: { accept: "text/markdown, text/plain;q=0.9, */*;q=0.1" },
+                signal: AbortSignal.timeout(5000),
+            });
+            if (!response.ok)
+                return had?.voice ?? null;
+            const text = (await response.text()).slice(0, 64 * 1024);
+            const voice = readProfileVoice(text);
+            this.kept.set(where.href, { at: this.now(), voice });
+            if (this.kept.size > 5000) {
+                for (const [key, one] of this.kept)
+                    if (this.now() - one.at > this.ttlMs)
+                        this.kept.delete(key);
+            }
+            return voice;
+        }
+        catch {
+            return had?.voice ?? null;
+        }
+    }
+}

package/package.json

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

package/src/handles.ts

@@ -22,8 +22,47 @@ const SCHEMA = `
     updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
   );
   CREATE UNIQUE INDEX IF NOT EXISTS ${TABLE}_lower ON ${TABLE} (lower(handle));
+  ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS voice TEXT NOT NULL DEFAULT '';
+  ALTER TABLE ${TABLE} ADD COLUMN IF NOT EXISTS profile TEXT NOT NULL DEFAULT '';
 `;
 
+/** What the room knows about somebody: the name, how they sound, where the rest is written. */
+export interface Persona {
+  handle: string;
+  /** female, male, "" for whichever, or a provider voice id they named. */
+  voice: string;
+  /** The URL of their OpenProfile.md, or "". */
+  profile: string;
+}
+
+/** A voice as it may be kept: a sex, nothing, or a provider's voice id. */
+export function cleanVoice(value: unknown): { voice: string; error: string } {
+  if (value === undefined || value === null) return { voice: "", error: "" };
+  if (typeof value !== "string") return { voice: "", error: "a voice is a word" };
+  const word = value.trim();
+  if (word === "" || word === "any") return { voice: "", error: "" };
+  const lower = word.toLowerCase();
+  if (lower === "female" || lower === "male") return { voice: lower, error: "" };
+  if (/^[A-Za-z][A-Za-z0-9_.-]{2,80}$/.test(word) && word.includes(".")) return { voice: word, error: "" };
+  return { voice: "", error: "female, male, any, or a voice id like Telnyx.KokoroTTS.am_adam" };
+}
+
+/** An OpenProfile address as it may be kept: an http(s) URL, or nothing. */
+export function cleanProfile(value: unknown): { profile: string; error: string } {
+  if (value === undefined || value === null) return { profile: "", error: "" };
+  if (typeof value !== "string") return { profile: "", error: "a profile is a URL" };
+  const text = value.trim();
+  if (text === "") return { profile: "", error: "" };
+  try {
+    const url = new URL(text);
+    if (url.protocol !== "https:" && url.protocol !== "http:") return { profile: "", error: "a profile is an http(s) URL" };
+    if (url.href.length > 500) return { profile: "", error: "that URL is too long" };
+    return { profile: url.href, error: "" };
+  } catch {
+    return { profile: "", error: "a profile is a URL, like https://you.example/.well-known/openprofile.md" };
+  }
+}
+
 /**
  * What a handle may be.
  *
@@ -87,6 +126,39 @@ export class Handles {
     return rows[0] ? String(rows[0]["handle"] ?? "") : "";
   }
 
+  /** Everything the room knows about somebody. Empty strings for whatever they never said. */
+  async persona(userId: string): Promise<Persona> {
+    await this.ensure();
+    const { rows } = await this.db.query(`SELECT handle, voice, profile FROM ${TABLE} WHERE user_id = $1`, [userId]);
+    const row = rows[0];
+    return {
+      handle: row ? String(row["handle"] ?? "") : "",
+      voice: row ? String(row["voice"] ?? "") : "",
+      profile: row ? String(row["profile"] ?? "") : "",
+    };
+  }
+
+  /**
+   * How somebody sounds, and where their profile is. Either may be given
+   * alone; what is not given is kept. A row exists only once a handle does,
+   * so somebody who never picked one is given the fallback handle first.
+   */
+  async describe(userId: string, fallbackHandle: string, wanted: { voice?: unknown; profile?: unknown }): Promise<{ persona: Persona | null; error: string }> {
+    const voice = wanted.voice === undefined ? null : cleanVoice(wanted.voice);
+    if (voice?.error) return { persona: null, error: voice.error };
+    const profile = wanted.profile === undefined ? null : cleanProfile(wanted.profile);
+    if (profile?.error) return { persona: null, error: profile.error };
+    await this.ensure();
+    const had = await this.persona(userId);
+    const handle = had.handle || cleanHandle(fallbackHandle) || fallbackHandle;
+    await this.db.query(
+      `INSERT INTO ${TABLE} (user_id, handle, voice, profile) VALUES ($1, $2, $3, $4)
+       ON CONFLICT (user_id) DO UPDATE SET voice = EXCLUDED.voice, profile = EXCLUDED.profile, updated_at = NOW()`,
+      [userId, handle, voice ? voice.voice : had.voice, profile ? profile.profile : had.profile],
+    );
+    return { persona: await this.persona(userId), error: "" };
+  }
+
   /**
    * Handles for a page of rows, in one query.
    *