- app/ (Electron 45 + TypeScript): the core joins one voice channel, decodes each speaker's Opus to 48 kHz stereo and streams it to the voice worker, sends speaking_end and speaker_leave, and emits speech_start/partial/final with the speaker's display name. - Sentence playback from the worker's TTS, first come first served, with stop that silences the clip at once and cancels unfinished requests; slash command join/leave/stop (create-or-update by name). - Transcription notice posted on every join; other bots ignored by default; at most maxSpeakers people transcribed at once. - Registered chat channels: live message events, history reads, sends split at 2,000 characters with mentions disabled; Message Content intent checked before login. - The app starts the Python voice worker with a fresh token in the environment, restarts it with backoff, and the worker client reconnects and fails in-flight TTS on a lost connection. - Spec in app/src/core/discord_core.spec.md; Vitest unit tests, a protocol test against the real Python worker server with fake engines, and an opt-in live test with two bots on real Discord. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
172 lines
7.1 KiB
TypeScript
172 lines
7.1 KiB
TypeScript
import { once } from "node:events";
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
import { WebSocketServer, type WebSocket } from "ws";
|
|
import { decodeTtsFrame, encodeAudioFrame, KIND_TTS } from "../src/core/frames.js";
|
|
import { VoiceWorkerClient, type TtsDone } from "../src/core/workerClient.js";
|
|
|
|
const TOKEN = "t0ken";
|
|
const FMT = { rate: 48000, channels: 2 } as const;
|
|
|
|
/** A stand-in voice worker: checks the hello and records what the client sends. */
|
|
async function fakeWorker(port = 0) {
|
|
const wss = new WebSocketServer({ host: "127.0.0.1", port });
|
|
await once(wss, "listening");
|
|
const received: (Record<string, unknown> | Buffer)[] = [];
|
|
const sockets: WebSocket[] = [];
|
|
wss.on("connection", (ws) => {
|
|
sockets.push(ws);
|
|
ws.on("message", (data, isBinary) => {
|
|
if (isBinary) return void received.push(data as Buffer);
|
|
const msg = JSON.parse(String(data));
|
|
received.push(msg);
|
|
if (msg.type === "hello") {
|
|
if (msg.token !== TOKEN) return ws.close(4401, "bad token");
|
|
ws.send(JSON.stringify({ type: "hello_ok", stt_ready: true, tts_ready: true, stt: msg.stt }));
|
|
}
|
|
});
|
|
});
|
|
const addr = wss.address() as { port: number };
|
|
return { wss, received, sockets, url: `ws://127.0.0.1:${addr.port}`, port: addr.port };
|
|
}
|
|
|
|
const cleanups: (() => void | Promise<void>)[] = [];
|
|
afterEach(async () => {
|
|
for (const c of cleanups.splice(0)) await c();
|
|
});
|
|
|
|
function client(url: string, extra: Partial<ConstructorParameters<typeof VoiceWorkerClient>[0]> = {}) {
|
|
const c = new VoiceWorkerClient({ url, token: TOKEN, audio: FMT, tts: FMT, backoffMs: 20, maxBackoffMs: 50, ...extra });
|
|
cleanups.push(() => c.close());
|
|
return c;
|
|
}
|
|
|
|
const until = async (pred: () => boolean, ms = 3000) => {
|
|
const end = Date.now() + ms;
|
|
while (!pred()) {
|
|
if (Date.now() > end) throw new Error("timed out");
|
|
await new Promise((r) => setTimeout(r, 10));
|
|
}
|
|
};
|
|
|
|
describe("VoiceWorkerClient", () => {
|
|
it("says hello with the token, formats and STT settings, then streams audio frames", async () => {
|
|
const w = await fakeWorker();
|
|
cleanups.push(() => void w.wss.close());
|
|
const c = client(w.url, { stt: { hotwords: ["자비스"] } });
|
|
c.start();
|
|
const ok = await c.waitReady(2000);
|
|
expect(ok.stt).toEqual({ hotwords: ["자비스"] });
|
|
expect(w.received[0]).toEqual({ type: "hello", token: TOKEN, audio: FMT, tts: FMT, stt: { hotwords: ["자비스"] } });
|
|
const pcm = Buffer.alloc(3840, 1);
|
|
c.sendAudio("123", pcm);
|
|
c.speakingEnd("123");
|
|
c.speakerLeave("123");
|
|
await until(() => w.received.length >= 4);
|
|
expect(w.received[1]).toEqual(encodeAudioFrame("123", pcm));
|
|
expect(w.received.slice(2)).toEqual([{ type: "speaking_end", speaker: "123" }, { type: "speaker_leave", speaker: "123" }]);
|
|
});
|
|
|
|
it("passes worker events on and only TTS audio of requests it opened", async () => {
|
|
const w = await fakeWorker();
|
|
cleanups.push(() => void w.wss.close());
|
|
const c = client(w.url);
|
|
c.start();
|
|
await c.waitReady(2000);
|
|
const finals: unknown[] = [];
|
|
const audio: { id: string; seq: number }[] = [];
|
|
const done: TtsDone[] = [];
|
|
c.on("final", (f) => finals.push(f));
|
|
c.on("tts_audio", (a) => audio.push({ id: a.id, seq: a.seq }));
|
|
c.on("tts_done", (d) => done.push(d));
|
|
expect(c.tts("r1", "안녕하세요.")).toBe(true);
|
|
await until(() => w.received.some((m) => !Buffer.isBuffer(m) && m.type === "tts"));
|
|
const ws = w.sockets[0]!;
|
|
const frame = (id: string, seq: number) => {
|
|
const s = Buffer.alloc(4);
|
|
s.writeUInt32LE(seq);
|
|
return Buffer.concat([Buffer.from([KIND_TTS, id.length]), Buffer.from(id), s, Buffer.alloc(8)]);
|
|
};
|
|
ws.send(frame("r1", 0));
|
|
ws.send(frame("zz", 0)); // not ours
|
|
ws.send(JSON.stringify({ type: "final", speaker: "1", utt: 1, text: "네", end_reason: "silence", audio_ms: 900,
|
|
wait_ms: 100, stt_ms: 80 }));
|
|
ws.send(JSON.stringify({ type: "tts_done", id: "r1", chunks: 1, cancelled: false, failed: false }));
|
|
await until(() => done.length === 1 && finals.length === 1);
|
|
expect(audio).toEqual([{ id: "r1", seq: 0 }]);
|
|
expect(decodeTtsFrame(frame("r1", 0))?.pcm.length).toBe(8);
|
|
expect(done[0]).toEqual({ id: "r1", chunks: 1, cancelled: false, failed: false });
|
|
});
|
|
|
|
it("a refused TTS request (no engine) ends as failed", async () => {
|
|
const w = await fakeWorker();
|
|
cleanups.push(() => void w.wss.close());
|
|
const c = client(w.url);
|
|
c.start();
|
|
await c.waitReady(2000);
|
|
const done: TtsDone[] = [];
|
|
c.on("tts_done", (d) => done.push(d));
|
|
c.tts("r9", "x");
|
|
await until(() => w.received.length >= 2);
|
|
w.sockets[0]!.send(JSON.stringify({ type: "error", code: "tts_unavailable", message: "no", id: "r9" }));
|
|
await until(() => done.length === 1);
|
|
expect(done[0]).toMatchObject({ id: "r9", failed: true });
|
|
});
|
|
|
|
it("reconnects after the worker restarts and fails the TTS that was in flight", async () => {
|
|
let w = await fakeWorker();
|
|
const port = w.port;
|
|
const c = client(w.url);
|
|
let readies = 0;
|
|
let disconnects = 0;
|
|
c.on("ready", () => readies++);
|
|
c.on("disconnected", () => disconnects++);
|
|
const done: TtsDone[] = [];
|
|
c.on("tts_done", (d) => done.push(d));
|
|
c.start();
|
|
await c.waitReady(2000);
|
|
c.tts("r1", "길게 말하는 중");
|
|
await until(() => w.received.length >= 2);
|
|
// The worker dies...
|
|
for (const s of w.sockets) s.terminate();
|
|
await new Promise<void>((r) => w.wss.close(() => r()));
|
|
await until(() => disconnects === 1);
|
|
expect(done).toEqual([{ id: "r1", chunks: 0, cancelled: false, failed: true }]);
|
|
expect(c.isReady).toBe(false);
|
|
// Audio while it is down is dropped, not queued.
|
|
c.sendAudio("1", Buffer.alloc(4));
|
|
// ...and comes back on the same port.
|
|
w = await fakeWorker(port);
|
|
cleanups.push(() => void w.wss.close());
|
|
await until(() => readies === 2);
|
|
expect(w.received[0]).toMatchObject({ type: "hello", token: TOKEN });
|
|
expect(w.received.filter(Buffer.isBuffer)).toEqual([]);
|
|
});
|
|
|
|
it("settings changed with configure() are sent now and in every later hello", async () => {
|
|
let w = await fakeWorker();
|
|
const port = w.port;
|
|
const c = client(w.url, { stt: { language: "ko" } });
|
|
c.start();
|
|
await c.waitReady(2000);
|
|
c.configure({ partials: false });
|
|
await until(() => w.received.length >= 2);
|
|
expect(w.received[1]).toEqual({ type: "config", partials: false });
|
|
for (const s of w.sockets) s.terminate();
|
|
await new Promise<void>((r) => w.wss.close(() => r()));
|
|
await until(() => !c.isReady);
|
|
w = await fakeWorker(port);
|
|
cleanups.push(() => void w.wss.close());
|
|
await until(() => c.isReady);
|
|
expect(w.received[0]).toMatchObject({ stt: { language: "ko", partials: false } });
|
|
});
|
|
|
|
it("tts while disconnected fails at once instead of waiting forever", async () => {
|
|
const c = client("ws://127.0.0.1:1");
|
|
const done: TtsDone[] = [];
|
|
c.on("tts_done", (d) => done.push(d));
|
|
expect(c.tts("r1", "x")).toBe(false);
|
|
await until(() => done.length === 1);
|
|
expect(done[0]).toMatchObject({ id: "r1", failed: true });
|
|
});
|
|
});
|