111 lines
6.1 KiB
JavaScript
111 lines
6.1 KiB
JavaScript
const crypto = require("crypto");
|
|
|
|
const PROTOCOL_VERSION = 1;
|
|
const AUDIO_MAGIC = Buffer.from("LACP");
|
|
const AUDIO_HEADER_BYTES = 64;
|
|
const MAX_JSON_BYTES = 64 * 1024;
|
|
const MAX_AUDIO_PAYLOAD_BYTES = 6400;
|
|
const CLIENT_TYPES = new Set(["hello", "ping", "source_update", "obs_state", "start", "stop", "ack"]);
|
|
|
|
function parseEnvelope(input) {
|
|
const bytes = Buffer.isBuffer(input) ? input : Buffer.from(String(input || ""), "utf8");
|
|
if (!bytes.length || bytes.length > MAX_JSON_BYTES) throw protocolError("MESSAGE_SIZE", "Structured message size is invalid.");
|
|
let value;
|
|
try { value = JSON.parse(bytes.toString("utf8")); }
|
|
catch { throw protocolError("INVALID_JSON", "Structured message is not valid JSON."); }
|
|
if (!value || Array.isArray(value) || typeof value !== "object") throw protocolError("INVALID_ENVELOPE", "Message envelope must be an object.");
|
|
if (value.version !== PROTOCOL_VERSION) throw protocolError("INCOMPATIBLE_VERSION", `Protocol version ${value.version} is unsupported.`);
|
|
if (!CLIENT_TYPES.has(value.type)) throw protocolError("UNKNOWN_TYPE", "Message type is not allowed.");
|
|
if (!isUuid(value.id)) throw protocolError("INVALID_ID", "Message id must be a UUID.");
|
|
if (!value.sent_at || !Number.isFinite(Date.parse(value.sent_at))) throw protocolError("INVALID_TIME", "Message sent_at must be an ISO timestamp.");
|
|
if (value.session_id != null && !isUuid(value.session_id)) throw protocolError("INVALID_SESSION", "Session id must be a UUID.");
|
|
if (value.payload != null && (Array.isArray(value.payload) || typeof value.payload !== "object")) throw protocolError("INVALID_PAYLOAD", "Message payload must be an object.");
|
|
return value;
|
|
}
|
|
|
|
function validateHello(envelope) {
|
|
if (envelope.type !== "hello") throw protocolError("HELLO_REQUIRED", "The first message must be hello.");
|
|
const payload = envelope.payload || {};
|
|
if (!shortVersion(payload.companion_version) || !shortVersion(payload.plugin_version)) throw protocolError("INVALID_HELLO", "Companion and plugin versions are required.");
|
|
if (!Array.isArray(payload.capabilities) || payload.capabilities.length > 32) throw protocolError("INVALID_CAPABILITIES", "Capabilities are invalid.");
|
|
if (!payload.capabilities.includes("transcription.capture.v1")) throw protocolError("MISSING_CAPABILITY", "The transcription capture capability is required.");
|
|
const audio = payload.audio || {};
|
|
if (audio.codec !== "pcm_s16le" || audio.sample_rate !== 16000 || audio.channels !== 1 || audio.bits !== 16) {
|
|
throw protocolError("UNSUPPORTED_AUDIO", "Protocol v1 requires 16 kHz mono signed 16-bit PCM.");
|
|
}
|
|
if (payload.resume_session_id != null && !isUuid(payload.resume_session_id)) throw protocolError("INVALID_RESUME", "Resume session id is invalid.");
|
|
return payload;
|
|
}
|
|
|
|
function parseAudioFrame(input) {
|
|
const frame = Buffer.from(input || []);
|
|
if (frame.length < AUDIO_HEADER_BYTES || frame.length > AUDIO_HEADER_BYTES + MAX_AUDIO_PAYLOAD_BYTES) {
|
|
throw protocolError("AUDIO_SIZE", "Audio frame size is invalid.");
|
|
}
|
|
if (!frame.subarray(0, 4).equals(AUDIO_MAGIC)) throw protocolError("AUDIO_MAGIC", "Audio frame magic is invalid.");
|
|
const version = frame.readUInt8(4);
|
|
const flags = frame.readUInt8(5);
|
|
const headerBytes = frame.readUInt16LE(6);
|
|
const payloadBytes = frame.readUInt32LE(60);
|
|
if (version !== PROTOCOL_VERSION || headerBytes !== AUDIO_HEADER_BYTES || frame.length !== headerBytes + payloadBytes) {
|
|
throw protocolError("AUDIO_HEADER", "Audio frame header is invalid.");
|
|
}
|
|
if (payloadBytes > MAX_AUDIO_PAYLOAD_BYTES || payloadBytes % 2 !== 0) throw protocolError("AUDIO_PAYLOAD", "PCM payload length is invalid.");
|
|
if (frame.readUInt32LE(52) !== 16000 || frame.readUInt16LE(56) !== 1 || frame.readUInt16LE(58) !== 16) {
|
|
throw protocolError("UNSUPPORTED_AUDIO", "Audio format is unsupported.");
|
|
}
|
|
return {
|
|
version,
|
|
active: Boolean(flags & 1),
|
|
muted: Boolean(flags & 2),
|
|
sequence: frame.readUInt32LE(8),
|
|
capture_timestamp_us: Number(frame.readBigUInt64LE(12)),
|
|
session_id: bytesToUuid(frame.subarray(20, 36)),
|
|
source_uuid: bytesToUuid(frame.subarray(36, 52)),
|
|
sample_rate: 16000,
|
|
channels: 1,
|
|
bits: 16,
|
|
pcm: frame.subarray(AUDIO_HEADER_BYTES)
|
|
};
|
|
}
|
|
|
|
function encodeAudioFrame(value) {
|
|
const pcm = Buffer.from(value.pcm || []);
|
|
if (pcm.length > MAX_AUDIO_PAYLOAD_BYTES || pcm.length % 2) throw protocolError("AUDIO_PAYLOAD", "PCM payload length is invalid.");
|
|
const frame = Buffer.alloc(AUDIO_HEADER_BYTES + pcm.length);
|
|
AUDIO_MAGIC.copy(frame, 0);
|
|
frame.writeUInt8(PROTOCOL_VERSION, 4);
|
|
frame.writeUInt8((value.active === false ? 0 : 1) | (value.muted ? 2 : 0), 5);
|
|
frame.writeUInt16LE(AUDIO_HEADER_BYTES, 6);
|
|
frame.writeUInt32LE(Number(value.sequence) >>> 0, 8);
|
|
frame.writeBigUInt64LE(BigInt(value.capture_timestamp_us || 0), 12);
|
|
uuidToBytes(value.session_id).copy(frame, 20);
|
|
uuidToBytes(value.source_uuid).copy(frame, 36);
|
|
frame.writeUInt32LE(16000, 52);
|
|
frame.writeUInt16LE(1, 56);
|
|
frame.writeUInt16LE(16, 58);
|
|
frame.writeUInt32LE(pcm.length, 60);
|
|
pcm.copy(frame, AUDIO_HEADER_BYTES);
|
|
return frame;
|
|
}
|
|
|
|
function envelope(type, payload = {}, sessionId = null) {
|
|
return { version: 1, type, id: crypto.randomUUID(), sent_at: new Date().toISOString(), session_id: sessionId, payload };
|
|
}
|
|
|
|
function protocolError(code, message) {
|
|
const error = new Error(message);
|
|
error.code = code;
|
|
return error;
|
|
}
|
|
|
|
function isUuid(value) {
|
|
return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(String(value || ""));
|
|
}
|
|
|
|
function shortVersion(value) { return typeof value === "string" && value.length > 0 && value.length <= 32; }
|
|
function uuidToBytes(value) { if (!isUuid(value)) throw protocolError("INVALID_UUID", "UUID is invalid."); return Buffer.from(value.replace(/-/g, ""), "hex"); }
|
|
function bytesToUuid(value) { const hex = Buffer.from(value).toString("hex"); return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`; }
|
|
|
|
module.exports = { PROTOCOL_VERSION, AUDIO_HEADER_BYTES, MAX_JSON_BYTES, MAX_AUDIO_PAYLOAD_BYTES, parseEnvelope, validateHello, parseAudioFrame, encodeAudioFrame, envelope, protocolError, isUuid };
|