viberoom 0.5.9 → 0.6.0

package/dist/ws.js

@@ -0,0 +1,175 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { createHash } from "node:crypto";
+const HANDSHAKE_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+export function acceptKey(key) {
+    return createHash("sha1").update(key + HANDSHAKE_GUID).digest("base64");
+}
+export const OPCODE = { continuation: 0, text: 1, binary: 2, close: 8, ping: 9, pong: 10 };
+export function encodeFrame(opcode, payload = Buffer.alloc(0)) {
+    const length = payload.length;
+    let header;
+    if (length < 126) {
+        header = Buffer.alloc(2);
+        header[1] = length;
+    }
+    else if (length < 65536) {
+        header = Buffer.alloc(4);
+        header[1] = 126;
+        header.writeUInt16BE(length, 2);
+    }
+    else {
+        header = Buffer.alloc(10);
+        header[1] = 127;
+        header.writeBigUInt64BE(BigInt(length), 2);
+    }
+    header[0] = 0x80 | (opcode & 0x0f);
+    return Buffer.concat([header, payload]);
+}
+export function encodeText(text) {
+    return encodeFrame(OPCODE.text, Buffer.from(text, "utf8"));
+}
+export function encodeClose(code = 1000, reason = "") {
+    const text = Buffer.from(reason, "utf8");
+    const payload = Buffer.alloc(2 + text.length);
+    payload.writeUInt16BE(code, 0);
+    text.copy(payload, 2);
+    return encodeFrame(OPCODE.close, payload);
+}
+export const MAX_FRAME_BYTES = 1 << 20;
+export function decodeFrames(buffer) {
+    const frames = [];
+    let offset = 0;
+    while (buffer.length - offset >= 2) {
+        const first = buffer[offset];
+        const second = buffer[offset + 1];
+        const fin = (first & 0x80) !== 0;
+        const opcode = first & 0x0f;
+        const masked = (second & 0x80) !== 0;
+        let length = second & 0x7f;
+        let position = offset + 2;
+        if (length === 126) {
+            if (buffer.length < position + 2)
+                break;
+            length = buffer.readUInt16BE(position);
+            position += 2;
+        }
+        else if (length === 127) {
+            if (buffer.length < position + 8)
+                break;
+            const big = buffer.readBigUInt64BE(position);
+            if (big > BigInt(MAX_FRAME_BYTES))
+                throw new Error(`frame of ${big} bytes refused`);
+            length = Number(big);
+            position += 8;
+        }
+        if (length > MAX_FRAME_BYTES)
+            throw new Error(`frame of ${length} bytes refused`);
+        let mask = null;
+        if (masked) {
+            if (buffer.length < position + 4)
+                break;
+            mask = buffer.subarray(position, position + 4);
+            position += 4;
+        }
+        if (buffer.length < position + length)
+            break;
+        const payload = Buffer.from(buffer.subarray(position, position + length));
+        if (mask)
+            for (let i = 0; i < payload.length; i++)
+                payload[i] ^= mask[i & 3];
+        frames.push({ fin, opcode, payload });
+        offset = position + length;
+    }
+    return { frames, rest: buffer.subarray(offset) };
+}
+export class WebSocketPeer {
+    socket;
+    buffer;
+    closed = false;
+    closeListeners = [];
+    alive = true;
+    constructor(socket, head = Buffer.alloc(0)) {
+        this.socket = socket;
+        this.buffer = Buffer.alloc(0);
+        socket.on("data", (chunk) => this.onData(chunk));
+        socket.on("close", () => this.finish());
+        socket.on("end", () => this.finish());
+        socket.on("error", () => this.finish());
+        if (head.length)
+            this.onData(head);
+    }
+    onClose(listener) {
+        this.closeListeners.push(listener);
+    }
+    send(text) {
+        if (this.closed)
+            return;
+        this.socket.write(encodeText(text));
+    }
+    ping() {
+        if (this.closed)
+            return;
+        this.alive = false;
+        this.socket.write(encodeFrame(OPCODE.ping));
+    }
+    close(code = 1000, reason = "") {
+        if (this.closed)
+            return;
+        try {
+            this.socket.write(encodeClose(code, reason));
+        }
+        catch {
+        }
+        this.socket.end();
+        this.finish();
+    }
+    onData(chunk) {
+        if (this.closed)
+            return;
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        let decoded;
+        try {
+            decoded = decodeFrames(this.buffer);
+        }
+        catch {
+            this.close(1009, "frame too large");
+            return;
+        }
+        this.buffer = Buffer.from(decoded.rest);
+        for (const frame of decoded.frames) {
+            if (frame.opcode === OPCODE.ping)
+                this.socket.write(encodeFrame(OPCODE.pong, frame.payload));
+            else if (frame.opcode === OPCODE.pong)
+                this.alive = true;
+            else if (frame.opcode === OPCODE.close) {
+                try {
+                    this.socket.write(encodeFrame(OPCODE.close, frame.payload.subarray(0, 2)));
+                }
+                catch {
+                }
+                this.socket.end();
+                this.finish();
+                return;
+            }
+        }
+    }
+    finish() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const listener of this.closeListeners)
+            listener();
+    }
+}
+export function acceptUpgrade(req, socket, head = Buffer.alloc(0)) {
+    const key = req.headers["sec-websocket-key"];
+    const upgrade = String(req.headers.upgrade ?? "").toLowerCase();
+    const version = req.headers["sec-websocket-version"];
+    if (upgrade !== "websocket" || typeof key !== "string" || version !== "13") {
+        socket.write("HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n");
+        socket.destroy();
+        return null;
+    }
+    socket.write(["HTTP/1.1 101 Switching Protocols", "Upgrade: websocket", "Connection: Upgrade", `Sec-WebSocket-Accept: ${acceptKey(key)}`, "", ""].join("\r\n"));
+    return new WebSocketPeer(socket, head);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viberoom",
-  "version": "0.5.9",
+  "version": "0.6.0",
   "description": "viberoom: group chat rooms for a human and several coding agents over the Agent Client Protocol",
   "type": "module",
   "engines": {
@@ -33,6 +33,7 @@
     "@agentclientprotocol/sdk": "1.4.0",
     "marked": "^16.4.2",
     "mermaid": "^11.17.2",
+    "prismjs": "^1.30.0",
     "zod": "^4.0.0"
   },
   "devDependencies": {