viberoom 0.5.8 → 0.6.0

package/dist/viewer.js

@@ -1,9 +1,76 @@
 // viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
-import { extname } from "node:path";
+import { extname, basename } from "node:path";
 export const VIEWER_MAX_BYTES = 2 * 1024 * 1024;
+export const WINDOW_MAX_LINES = 500;
+export const STREAM_MAX_BYTES = 64 * 1024 * 1024;
 const KINDS = { ".md": "markdown", ".markdown": "markdown", ".csv": "csv", ".tsv": "csv" };
 export function viewerKind(path) {
-    return KINDS[extname(path).toLowerCase()] ?? null;
+    return KINDS[extname(path).toLowerCase()] ?? "text";
+}
+const LANGUAGES = {
+    ".ts": "typescript", ".mts": "typescript", ".cts": "typescript", ".tsx": "tsx",
+    ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript", ".jsx": "jsx",
+    ".json": "json", ".jsonc": "json", ".json5": "json",
+    ".py": "python", ".rb": "ruby", ".php": "php", ".pl": "perl", ".lua": "lua", ".r": "r",
+    ".rs": "rust", ".go": "go", ".java": "java", ".kt": "kotlin", ".kts": "kotlin", ".swift": "swift",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".cxx": "cpp", ".hpp": "cpp", ".hh": "cpp",
+    ".cs": "csharp", ".fs": "fsharp", ".scala": "scala", ".dart": "dart", ".ex": "elixir", ".exs": "elixir",
+    ".sh": "bash", ".bash": "bash", ".zsh": "bash", ".ps1": "powershell", ".psm1": "powershell", ".bat": "batch", ".cmd": "batch",
+    ".sql": "sql", ".graphql": "graphql", ".gql": "graphql", ".proto": "protobuf",
+    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".ini": "ini", ".cfg": "ini", ".conf": "ini", ".env": "bash",
+    ".xml": "xml", ".html": "html", ".htm": "html", ".svg": "xml", ".vue": "html",
+    ".css": "css", ".scss": "scss", ".sass": "scss", ".less": "less",
+    ".diff": "diff", ".patch": "diff",
+};
+const NAMED_FILES = {
+    dockerfile: "docker",
+    makefile: "makefile",
+    ".gitignore": "bash",
+    ".npmrc": "ini",
+    ".editorconfig": "ini",
+};
+export function languageOf(path) {
+    const name = basename(path).toLowerCase();
+    if (NAMED_FILES[name])
+        return NAMED_FILES[name];
+    return LANGUAGES[extname(path).toLowerCase()] || null;
+}
+const IMAGE_MEDIA = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".webp": "image/webp",
+    ".bmp": "image/bmp",
+    ".avif": "image/avif",
+    ".ico": "image/x-icon",
+    ".svg": "image/svg+xml",
+};
+export const IMAGE_VIEW_MAX_BYTES = 20 * 1024 * 1024;
+export function imageMediaType(path) {
+    return IMAGE_MEDIA[extname(path).toLowerCase()] ?? null;
+}
+export function looksBinary(head) {
+    if (!head.length)
+        return false;
+    let control = 0;
+    for (const byte of head) {
+        if (byte === 0)
+            return true;
+        if (byte < 32 && byte !== 9 && byte !== 10 && byte !== 13 && byte !== 12)
+            control++;
+    }
+    return control / head.length > 0.1;
+}
+export function sliceLines(text, from, to) {
+    const all = text.split(/\r?\n/);
+    if (all.length && all[all.length - 1] === "")
+        all.pop();
+    const lines = all.length;
+    const start = Math.max(1, Math.min(Math.floor(from ?? 1) || 1, Math.max(1, lines)));
+    const wanted = Math.floor(to ?? start + WINDOW_MAX_LINES - 1) || start;
+    const end = Math.max(start, Math.min(wanted, lines, start + WINDOW_MAX_LINES - 1));
+    return { text: all.slice(start - 1, end).join("\n"), from: start, to: end, lines };
 }
 export function detectDelimiter(text) {
     const first = text.split(/\r?\n/, 1)[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.8",
+  "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": {