Voice for bots

POST https://baff.gg/api/channels/{channelId}/voice
Authorization: Bot bfx_4f1c...

{
	"url": "wss://baff.gg/livekit",
	"token": "eyJhbGciOiJIUzI1NiIs...",
	"canSpeak": true,
	"canVideo": false,
	"deafened": true,
	"room": "voice:103700000000000005",
	"identity": "103712345678901248",
	"serverId": "103700000000000000",
	"channelId": "103700000000000005"
}

{
	"t": "VOICE_STATE_UPDATE",
	"d": {
		"userId": "103712345678901248",
		"serverId": "103700000000000000",
		"channelId": "103700000000000005",
		"muted": false,
		"deafened": true,
		"selfVideo": false,
		"selfStream": false
	}
}

PATCH https://baff.gg/api/voice
Authorization: Bot bfx_4f1c...
Content-Type: application/json

{ "muted": true, "serverId": "103700000000000000" }

{
	"t": "SOUNDBOARD_PLAY",
	"d": {
		"channelId": "103700000000000010",
		"serverId": "103700000000000000",
		"userId": "103700000000000042",
		"sound": { "id": "104200000000000000", "serverId": "103700000000000000", "name": "Air horn", "emoji": null, "volume": 1, "durationSecs": 1.8, "url": "https://cdn.baff.gg/soundboard/104200000000000000.mp3", "uploader": "Ana" }
	}
}

POST https://baff.gg/api/channels/{channelId}/soundboard
Authorization: Bot bfx_4f1c...
Content-Type: application/json

{ "soundId": "104200000000000000" }

DELETE https://baff.gg/api/voice?serverId=103700000000000000
Authorization: Bot bfx_4f1c...

npm install @livekit/rtc-node
BOT_TOKEN=bfx_... node play.mjs 103700000000000005 song.wav

// play.mjs: node play.mjs <voiceChannelId> <file.wav>
import { readFileSync } from 'node:fs';
import { AudioFrame, AudioSource, LocalAudioTrack, Room, RoomEvent, TrackPublishOptions, TrackSource } from '@livekit/rtc-node';

const API = 'https://baff.gg/api';
const GATEWAY = 'wss://baff.gg/api/gateway';
const TOKEN = process.env.BOT_TOKEN;
const auth = { Authorization: `Bot ${TOKEN}` };
const [channelId, file] = process.argv.slice(2);

// Reads a 16-bit PCM WAV: its sample rate, channel count and samples (interleaved).
function readWav(path) {
	const buf = readFileSync(path);
	if (buf.toString('ascii', 0, 4) !== 'RIFF' || buf.toString('ascii', 8, 12) !== 'WAVE') throw new Error('Not a WAV file');
	let format;
	for (let at = 12; at + 8 <= buf.length; ) {
		const id = buf.toString('ascii', at, at + 4);
		const size = buf.readUInt32LE(at + 4);
		const body = at + 8;
		if (id === 'fmt ') {
			format = { pcm: buf.readUInt16LE(body) === 1, channels: buf.readUInt16LE(body + 2), sampleRate: buf.readUInt32LE(body + 4), bits: buf.readUInt16LE(body + 14) };
		} else if (id === 'data') {
			if (!format?.pcm || format.bits !== 16) throw new Error('Only 16-bit PCM WAV files are supported');
			const data = buf.subarray(body, body + size);
			const samples = new Int16Array(data.buffer.slice(data.byteOffset, data.byteOffset + data.length - (data.length % 2)));
			return { ...format, samples };
		}
		at = body + size + (size % 2);
	}
	throw new Error('No audio in this WAV file');
}

// 1. Connect to the gateway. A bot has to be connected to join voice, and closing this socket
//    takes it out of its calls.
const gateway = new WebSocket(GATEWAY, { headers: auth });
await new Promise((resolve, reject) => {
	gateway.addEventListener('message', (e) => JSON.parse(e.data).t === 'READY' && resolve());
	gateway.addEventListener('error', () => reject(new Error('Gateway connection failed')));
});

// 2. Ask baff.gg for a ticket into the channel.
const res = await fetch(`${API}/channels/${channelId}/voice`, { method: 'POST', headers: auth });
if (!res.ok) throw new Error(`Join failed: ${res.status} ${await res.text()}`);
const { url, token, serverId } = await res.json();

// 3. Connect to LiveKit. The ticket can't receive anything, so there's nothing to subscribe to.
const room = new Room();
let leaving = false;
room.on(RoomEvent.Disconnected, (reason) => {
	// Kicked from the server, moved, token reset, or we left: stop playing and quit.
	if (!leaving) console.log('Disconnected from voice, reason', reason);
	gateway.close();
	process.exit(0);
});
await room.connect(url, token, { autoSubscribe: false, dynacast: false });

// 4. Publish one audio track, fed from an AudioSource.
const wav = readWav(file);
const source = new AudioSource(wav.sampleRate, wav.channels);
const track = LocalAudioTrack.createAudioTrack('music', source);
await room.localParticipant.publishTrack(track, new TrackPublishOptions({ source: TrackSource.SOURCE_MICROPHONE }));

// 5. Feed it 10 ms at a time. captureFrame waits while its buffer is full, so this plays in
//    real time instead of all at once.
const perFrame = wav.sampleRate / 100;
const step = perFrame * wav.channels;
for (let i = 0; i + step <= wav.samples.length; i += step) {
	await source.captureFrame(new AudioFrame(wav.samples.slice(i, i + step), wav.sampleRate, wav.channels, perFrame));
}
await source.waitForPlayout();

// 6. Done: leave. baff.gg ends the LiveKit connection, which fires Disconnected above.
leaving = true;
await fetch(`${API}/voice?serverId=${serverId}`, { method: 'DELETE', headers: auth });
await room.disconnect();

import { spawn } from 'node:child_process';

const RATE = 48000;
const CHANNELS = 2;
const STEP = (RATE / 100) * CHANNELS * 2; // bytes in 10 ms

const source = new AudioSource(RATE, CHANNELS);
// ...publish a LocalAudioTrack made from it, as above...

async function play(input) {
	const ffmpeg = spawn('ffmpeg', ['-loglevel', 'error', '-i', input, '-f', 's16le', '-ar', String(RATE), '-ac', String(CHANNELS), 'pipe:1']);
	let pending = Buffer.alloc(0);
	for await (const chunk of ffmpeg.stdout) {
		pending = Buffer.concat([pending, chunk]);
		while (pending.length >= STEP) {
			const frame = pending.subarray(0, STEP);
			pending = pending.subarray(STEP);
			const samples = new Int16Array(frame.buffer.slice(frame.byteOffset, frame.byteOffset + STEP));
			await source.captureFrame(new AudioFrame(samples, RATE, CHANNELS, RATE / 100));
		}
	}
	await source.waitForPlayout();
}