viberoom 0.2.0

package/dist/hub.js

@@ -0,0 +1,348 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { EventEmitter } from "node:events";
+import { randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, renameSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { DEFAULT_EDITOR_SETTINGS } from "./open.js";
+import { listRecipes } from "./recipes.js";
+import { DEFAULT_ROOM_SETTINGS } from "./persona.js";
+import { Room } from "./room.js";
+import { SkillLibrary } from "./skills.js";
+export const DIAGRAM_PRESETS = ["pop", "lavender", "mint", "sunset", "slate"];
+const ROOM_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,39}$/;
+const INSTRUCTION_FILES = ["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".cursorrules"];
+export class Hub extends EventEmitter {
+    dataDir;
+    rooms = new Map();
+    skills;
+    settings;
+    log;
+    optionCache = new Map();
+    mcpTokens = new Map();
+    hubUrl = null;
+    skillsBridge;
+    constructor(dataDir, log, initialHumanName) {
+        super();
+        this.dataDir = resolve(dataDir);
+        this.log = log;
+        mkdirSync(join(this.dataDir, "rooms"), { recursive: true });
+        this.skills = new SkillLibrary(join(this.dataDir, "skills"), log.child("skills"));
+        try {
+            this.skills.seedBuiltins();
+        }
+        catch (error) {
+            log.warn(`built-in skills could not be seeded: ${String(error)}`);
+        }
+        this.skillsBridge = {
+            library: this.skills,
+            serverScript: fileURLToPath(new URL("./mcp-skills-server.js", import.meta.url)),
+            hubUrl: () => this.hubUrl,
+            needApproval: () => this.settings.agentSkillsNeedApproval === true,
+            save: (draft) => {
+                const { body: _b, ...meta } = this.saveSkillInternal(draft);
+                return meta;
+            },
+            issueToken: (roomId, participantId) => {
+                const token = randomBytes(18).toString("base64url");
+                this.mcpTokens.set(token, { roomId, participantId });
+                return token;
+            },
+            revokeToken: (token) => {
+                this.mcpTokens.delete(token);
+            },
+        };
+        this.settings = this.loadSettings(initialHumanName);
+        this.loadRooms();
+    }
+    setHubUrl(url) {
+        this.hubUrl = url.replace(/\/+$/, "");
+    }
+    resolveMcpToken(token) {
+        const entry = this.mcpTokens.get(token);
+        if (!entry)
+            return null;
+        const room = this.rooms.get(entry.roomId);
+        return room ? { room, participantId: entry.participantId } : null;
+    }
+    listSkills() {
+        return this.skills.list();
+    }
+    saveSkill(draft) {
+        const { body: _b, ...meta } = this.saveSkillInternal({ ...draft, reviewed: true, draft: false });
+        return meta;
+    }
+    saveSkillInternal(draft) {
+        const skill = this.skills.save(draft);
+        this.skillsChanged(skill.name);
+        return skill;
+    }
+    approveSkill(name) {
+        const skill = this.skills.approve(name);
+        this.skillsChanged(skill.name);
+        const { body: _b, ...meta } = skill;
+        return meta;
+    }
+    removeSkill(name) {
+        this.skills.remove(name);
+        this.skillsChanged(name);
+    }
+    skillsChanged(name) {
+        for (const room of this.rooms.values())
+            room.skillChanged(name);
+        this.emit("event", { type: "skills", skills: this.skills.list() });
+    }
+    settingsPath() {
+        return join(this.dataDir, "settings.json");
+    }
+    loadSettings(initialHumanName) {
+        const defaults = {
+            humanName: initialHumanName ?? "Human",
+            humanDescription: "",
+            humanAvatar: "",
+            bypassPermissionsByDefault: true,
+            profileCompleted: !!initialHumanName,
+            agentSkillsNeedApproval: false,
+            diagrams: { preset: "pop", primary: null },
+            editor: { ...DEFAULT_EDITOR_SETTINGS },
+            roomDefaults: {},
+            vendorPresets: {},
+        };
+        if (!existsSync(this.settingsPath())) {
+            writeJson(this.settingsPath(), defaults);
+            return defaults;
+        }
+        try {
+            const raw = JSON.parse(readFileSync(this.settingsPath(), "utf8"));
+            return { ...defaults, ...raw, roomDefaults: raw.roomDefaults ?? {}, vendorPresets: raw.vendorPresets ?? {} };
+        }
+        catch (error) {
+            this.log.warn(`settings.json unreadable (${String(error)}); using defaults`);
+            return defaults;
+        }
+    }
+    updateSettings(patch) {
+        const next = { ...this.settings, roomDefaults: { ...this.settings.roomDefaults }, vendorPresets: { ...this.settings.vendorPresets } };
+        if (patch.humanName !== undefined) {
+            const name = String(patch.humanName).trim();
+            if (!/^[\p{L}\p{N}][\p{L}\p{N}_-]{0,23}$/u.test(name))
+                throw new Error("humanName must be 1-24 letters, digits, _ or - (no spaces)");
+            next.humanName = name;
+        }
+        if (patch.humanDescription !== undefined)
+            next.humanDescription = String(patch.humanDescription).slice(0, 200);
+        if (patch.humanAvatar !== undefined)
+            next.humanAvatar = String(patch.humanAvatar).slice(0, 8);
+        if (patch.bypassPermissionsByDefault !== undefined)
+            next.bypassPermissionsByDefault = patch.bypassPermissionsByDefault === true || patch.bypassPermissionsByDefault === "true";
+        if (patch.profileCompleted !== undefined)
+            next.profileCompleted = patch.profileCompleted === true || patch.profileCompleted === "true";
+        if (patch.agentSkillsNeedApproval !== undefined)
+            next.agentSkillsNeedApproval = patch.agentSkillsNeedApproval === true || patch.agentSkillsNeedApproval === "true";
+        if (patch.diagrams !== undefined && typeof patch.diagrams === "object" && patch.diagrams) {
+            const d = patch.diagrams;
+            const preset = String(d.preset ?? next.diagrams?.preset ?? "pop");
+            if (!DIAGRAM_PRESETS.includes(preset))
+                throw new Error(`diagrams.preset must be one of ${DIAGRAM_PRESETS.join(", ")}`);
+            let primary = next.diagrams?.primary ?? null;
+            if (d.primary !== undefined) {
+                primary = d.primary === null || d.primary === "" ? null : String(d.primary).trim().toLowerCase();
+                if (primary !== null && !/^#[0-9a-f]{6}$/.test(primary))
+                    throw new Error("diagrams.primary must be a #rrggbb colour or empty");
+            }
+            next.diagrams = { preset, primary };
+        }
+        if (!next.diagrams)
+            next.diagrams = { preset: "pop", primary: null };
+        if (patch.editor !== undefined && typeof patch.editor === "object" && patch.editor) {
+            const e = patch.editor;
+            const mode = String(e.mode ?? next.editor?.mode ?? "auto");
+            if (mode !== "auto" && mode !== "default-app" && mode !== "custom")
+                throw new Error("editor.mode must be auto, default-app or custom");
+            const command = String(e.command ?? next.editor?.command ?? "").trim().slice(0, 500);
+            if (mode === "custom" && !command.includes("{file}"))
+                throw new Error("editor.command must mention {file} (and usually {line})");
+            next.editor = { mode, command };
+        }
+        if (!next.editor)
+            next.editor = { ...DEFAULT_EDITOR_SETTINGS };
+        if (patch.roomDefaults !== undefined && typeof patch.roomDefaults === "object" && patch.roomDefaults) {
+            next.roomDefaults = { ...next.roomDefaults, ...patch.roomDefaults };
+        }
+        if (patch.vendorPresets !== undefined && typeof patch.vendorPresets === "object" && patch.vendorPresets) {
+            for (const [vendor, preset] of Object.entries(patch.vendorPresets)) {
+                next.vendorPresets[vendor] = {
+                    model: preset?.model ?? null,
+                    effort: preset?.effort ?? null,
+                    mode: preset?.mode ?? null,
+                };
+            }
+        }
+        this.settings = next;
+        writeJson(this.settingsPath(), this.settings);
+        for (const room of this.rooms.values()) {
+            room.applyProgramSettings({
+                humanName: next.humanName,
+                humanDescription: next.humanDescription,
+                bypassPermissionsByDefault: next.bypassPermissionsByDefault,
+            });
+        }
+        this.emit("event", { type: "settings", settings: this.settings });
+        this.saveRooms();
+        return this.settings;
+    }
+    roomsPath() {
+        return join(this.dataDir, "rooms.json");
+    }
+    loadRooms() {
+        if (!existsSync(this.roomsPath()))
+            return;
+        let file;
+        try {
+            file = JSON.parse(readFileSync(this.roomsPath(), "utf8"));
+        }
+        catch (error) {
+            this.log.warn(`rooms.json unreadable (${String(error)}); starting with no rooms`);
+            return;
+        }
+        for (const stored of file.rooms ?? []) {
+            try {
+                const room = this.instantiate(stored.id, stored.name, stored.dir, stored.settings, stored.createdAt);
+                room.restore(stored.participants ?? []);
+                this.log.info(`restored room "${stored.name}" (${stored.id}): ${room.messages.length} messages, ${stored.participants?.length ?? 0} participants offline`);
+            }
+            catch (error) {
+                this.log.error(`could not restore room ${stored.id}: ${String(error)}`);
+            }
+        }
+    }
+    saveRooms() {
+        const file = {
+            version: 1,
+            rooms: [...this.rooms.values()].map((room) => room.toStored()),
+        };
+        writeJson(this.roomsPath(), file);
+    }
+    instantiate(id, name, dir, settings, createdAt) {
+        const room = new Room({
+            id,
+            name,
+            dir,
+            dataDir: join(this.dataDir, "rooms", id),
+            createdAt,
+            humanName: this.settings.humanName,
+            programHumanDescription: this.settings.humanDescription,
+            bypassPermissionsByDefault: this.settings.bypassPermissionsByDefault,
+            settings: { ...this.settings.roomDefaults, ...settings },
+            log: this.log.child(`room:${id}`),
+            optionCache: this.optionCache,
+            skills: this.skillsBridge,
+        });
+        room.on("event", (event) => {
+            this.emit("event", { type: "room.event", roomId: id, event });
+            if (event.type === "participant" || event.type === "participant.removed" || event.type === "room")
+                this.saveRooms();
+        });
+        this.rooms.set(id, room);
+        return room;
+    }
+    workspaceNotice(dir) {
+        const found = INSTRUCTION_FILES.filter((f) => existsSync(join(dir, f)));
+        if (existsSync(join(dir, ".cursor", "rules")))
+            found.push(".cursor/rules");
+        return found.length ? `The working directory contains ${found.join(", ")}; agents will read these by their own conventions in addition to the room brief.` : null;
+    }
+    createRoom(input) {
+        const name = input.name.trim();
+        if (!name || name.length > 60)
+            throw new Error("room name must be 1-60 characters");
+        let id = slugify(name);
+        if (!ROOM_ID_PATTERN.test(id))
+            id = `room-${Date.now().toString(36)}`;
+        let candidate = id;
+        for (let n = 2; this.rooms.has(candidate); n++)
+            candidate = `${id}-${n}`;
+        id = candidate;
+        const notices = [];
+        let dir;
+        if (input.dir && input.dir.trim()) {
+            dir = resolve(input.dir.trim());
+            if (!existsSync(dir))
+                throw new Error(`working directory does not exist: ${dir}`);
+            const notice = this.workspaceNotice(dir);
+            if (notice)
+                notices.push(notice);
+        }
+        else {
+            dir = join(this.dataDir, "rooms", id, "workspace");
+            mkdirSync(dir, { recursive: true });
+        }
+        const room = this.instantiate(id, name, dir, input.settings ?? {}, Date.now());
+        for (const notice of notices)
+            room.postNotice(notice);
+        this.saveRooms();
+        this.emit("event", { type: "room.created", room: room.snapshot() });
+        this.log.info(`created room "${name}" (${id}) with workspace ${dir}`);
+        return { room, notices };
+    }
+    getRoom(id) {
+        const room = this.rooms.get(id);
+        if (!room)
+            throw new Error(`no such room: ${id}`);
+        return room;
+    }
+    async removeRoom(id) {
+        const room = this.getRoom(id);
+        await room.shutdown();
+        this.rooms.delete(id);
+        this.saveRooms();
+        this.emit("event", { type: "room.removed", roomId: id });
+        this.log.info(`removed room ${id} (history kept on disk)`);
+    }
+    snapshot() {
+        return {
+            settings: this.settings,
+            recipes: listRecipes().map(({ build: _b, ...r }) => r),
+            skills: this.skills.list(),
+            roomDefaults: { ...DEFAULT_ROOM_SETTINGS, ...this.settings.roomDefaults },
+            rooms: [...this.rooms.values()].map((room) => room.snapshot()),
+        };
+    }
+    async shutdown() {
+        for (const room of this.rooms.values())
+            await room.shutdown();
+        this.saveRooms();
+    }
+    async reset() {
+        this.log.warn("erasing the whole data folder on the human's request");
+        for (const room of this.rooms.values())
+            await room.shutdown();
+        this.rooms.clear();
+        for (const token of this.mcpTokens.keys())
+            this.mcpTokens.delete(token);
+        rmSync(join(this.dataDir, "rooms"), { recursive: true, force: true });
+        rmSync(this.roomsPath(), { force: true });
+        rmSync(this.skills.dir, { recursive: true, force: true });
+        mkdirSync(join(this.dataDir, "rooms"), { recursive: true });
+        mkdirSync(this.skills.dir, { recursive: true });
+        this.skills.list();
+        this.skills.seedBuiltins();
+        rmSync(this.settingsPath(), { force: true });
+        this.settings = this.loadSettings();
+        this.emit("event", { type: "reset" });
+    }
+}
+function slugify(name) {
+    return name
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40);
+}
+function writeJson(path, value) {
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(value, null, 2));
+    renameSync(tmp, path);
+}

package/dist/icons.js

@@ -0,0 +1,235 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { deflateSync, inflateSync } from "node:zlib";
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+function assertPng(icon) {
+    if (icon.data.length < 8 || !icon.data.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw new Error(`icon ${icon.size}: not a PNG`);
+}
+const CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
+export function decodePng(png) {
+    if (png.length < 8 || !png.subarray(0, 8).equals(PNG_SIGNATURE))
+        throw new Error("not a PNG");
+    let width = 0;
+    let height = 0;
+    let bitDepth = 0;
+    let colorType = 0;
+    let interlace = 0;
+    let palette;
+    let trns;
+    const idat = [];
+    let pos = 8;
+    while (pos + 8 <= png.length) {
+        const len = png.readUInt32BE(pos);
+        const type = png.toString("ascii", pos + 4, pos + 8);
+        const body = png.subarray(pos + 8, pos + 8 + len);
+        if (type === "IHDR") {
+            width = body.readUInt32BE(0);
+            height = body.readUInt32BE(4);
+            bitDepth = body[8];
+            colorType = body[9];
+            interlace = body[12];
+        }
+        else if (type === "PLTE")
+            palette = body;
+        else if (type === "tRNS")
+            trns = body;
+        else if (type === "IDAT")
+            idat.push(body);
+        else if (type === "IEND")
+            break;
+        pos += 12 + len;
+    }
+    const channels = CHANNELS[colorType];
+    if (!width || !height || !channels)
+        throw new Error("png: unsupported image header");
+    if (bitDepth !== 8 || interlace !== 0)
+        throw new Error("png: only 8-bit non-interlaced images are supported");
+    const raw = inflateSync(Buffer.concat(idat));
+    const stride = width * channels;
+    const out = Buffer.alloc(width * height * 4);
+    let prev = Buffer.alloc(stride);
+    let p = 0;
+    for (let y = 0; y < height; y++) {
+        const filter = raw[p++];
+        const line = Buffer.from(raw.subarray(p, p + stride));
+        p += stride;
+        for (let i = 0; i < stride; i++) {
+            const a = i >= channels ? line[i - channels] : 0;
+            const b = prev[i];
+            const c = i >= channels ? prev[i - channels] : 0;
+            let v = line[i];
+            if (filter === 1)
+                v += a;
+            else if (filter === 2)
+                v += b;
+            else if (filter === 3)
+                v += Math.floor((a + b) / 2);
+            else if (filter === 4) {
+                const pp = a + b - c;
+                const pa = Math.abs(pp - a);
+                const pb = Math.abs(pp - b);
+                const pc = Math.abs(pp - c);
+                v += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+            }
+            else if (filter !== 0)
+                throw new Error(`png: unknown filter ${filter}`);
+            line[i] = v & 255;
+        }
+        for (let x = 0; x < width; x++) {
+            const o = (y * width + x) * 4;
+            const s = x * channels;
+            if (colorType === 6) {
+                out[o] = line[s];
+                out[o + 1] = line[s + 1];
+                out[o + 2] = line[s + 2];
+                out[o + 3] = line[s + 3];
+            }
+            else if (colorType === 2) {
+                out[o] = line[s];
+                out[o + 1] = line[s + 1];
+                out[o + 2] = line[s + 2];
+                out[o + 3] = 255;
+            }
+            else if (colorType === 0 || colorType === 4) {
+                out[o] = out[o + 1] = out[o + 2] = line[s];
+                out[o + 3] = colorType === 4 ? line[s + 1] : 255;
+            }
+            else {
+                const idx = line[s];
+                const pal = palette ?? Buffer.alloc(0);
+                out[o] = pal[idx * 3] ?? 0;
+                out[o + 1] = pal[idx * 3 + 1] ?? 0;
+                out[o + 2] = pal[idx * 3 + 2] ?? 0;
+                out[o + 3] = trns && idx < trns.length ? trns[idx] : 255;
+            }
+        }
+        prev = line;
+    }
+    return { width, height, data: out };
+}
+let crcTable;
+function crc32(buf) {
+    if (!crcTable) {
+        crcTable = new Uint32Array(256);
+        for (let n = 0; n < 256; n++) {
+            let c = n;
+            for (let k = 0; k < 8; k++)
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            crcTable[n] = c >>> 0;
+        }
+    }
+    let crc = 0xffffffff;
+    for (const byte of buf)
+        crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+    return (crc ^ 0xffffffff) >>> 0;
+}
+export function encodePng(img) {
+    const { width, height, data } = img;
+    const rowLen = width * 4 + 1;
+    const raw = Buffer.alloc(rowLen * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * rowLen] = 0;
+        data.copy(raw, y * rowLen + 1, y * width * 4, (y + 1) * width * 4);
+    }
+    const chunk = (type, body) => {
+        const len = Buffer.alloc(4);
+        len.writeUInt32BE(body.length, 0);
+        const typed = Buffer.concat([Buffer.from(type, "ascii"), body]);
+        const crc = Buffer.alloc(4);
+        crc.writeUInt32BE(crc32(typed), 0);
+        return Buffer.concat([len, typed, crc]);
+    };
+    const ihdr = Buffer.alloc(13);
+    ihdr.writeUInt32BE(width, 0);
+    ihdr.writeUInt32BE(height, 4);
+    ihdr[8] = 8;
+    ihdr[9] = 6;
+    return Buffer.concat([PNG_SIGNATURE, chunk("IHDR", ihdr), chunk("IDAT", deflateSync(raw)), chunk("IEND", Buffer.alloc(0))]);
+}
+export function dibFromRgba(img) {
+    const { width, height, data } = img;
+    const maskStride = Math.ceil(width / 32) * 4;
+    const header = Buffer.alloc(40);
+    header.writeUInt32LE(40, 0);
+    header.writeInt32LE(width, 4);
+    header.writeInt32LE(height * 2, 8);
+    header.writeUInt16LE(1, 12);
+    header.writeUInt16LE(32, 14);
+    header.writeUInt32LE(0, 16);
+    header.writeUInt32LE(width * height * 4 + maskStride * height, 20);
+    const pixels = Buffer.alloc(width * height * 4);
+    const mask = Buffer.alloc(maskStride * height);
+    for (let y = 0; y < height; y++) {
+        const srcRow = height - 1 - y;
+        for (let x = 0; x < width; x++) {
+            const s = (srcRow * width + x) * 4;
+            const d = (y * width + x) * 4;
+            pixels[d] = data[s + 2];
+            pixels[d + 1] = data[s + 1];
+            pixels[d + 2] = data[s];
+            pixels[d + 3] = data[s + 3];
+            if (data[s + 3] < 128)
+                mask[y * maskStride + (x >> 3)] |= 0x80 >> (x & 7);
+        }
+    }
+    return Buffer.concat([header, pixels, mask]);
+}
+export function packIco(icons) {
+    if (!icons.length)
+        throw new Error("no icons");
+    const sorted = [...icons].sort((a, b) => a.size - b.size);
+    for (const icon of sorted)
+        assertPng(icon);
+    const payloads = sorted.map((icon) => (icon.size >= 256 ? icon.data : dibFromRgba(decodePng(icon.data))));
+    const header = Buffer.alloc(6);
+    header.writeUInt16LE(0, 0);
+    header.writeUInt16LE(1, 2);
+    header.writeUInt16LE(sorted.length, 4);
+    const entries = [];
+    let offset = 6 + 16 * sorted.length;
+    sorted.forEach((icon, i) => {
+        const entry = Buffer.alloc(16);
+        entry.writeUInt8(icon.size >= 256 ? 0 : icon.size, 0);
+        entry.writeUInt8(icon.size >= 256 ? 0 : icon.size, 1);
+        entry.writeUInt8(0, 2);
+        entry.writeUInt8(0, 3);
+        entry.writeUInt16LE(1, 4);
+        entry.writeUInt16LE(32, 6);
+        entry.writeUInt32LE(payloads[i].length, 8);
+        entry.writeUInt32LE(offset, 12);
+        entries.push(entry);
+        offset += payloads[i].length;
+    });
+    return Buffer.concat([header, ...entries, ...payloads]);
+}
+const ICNS_TYPES = { 16: "icp4", 32: "icp5", 64: "icp6", 128: "ic07", 256: "ic08", 512: "ic09", 1024: "ic10" };
+export function packIcns(icons) {
+    const chunks = [];
+    for (const icon of [...icons].sort((a, b) => a.size - b.size)) {
+        const type = ICNS_TYPES[icon.size];
+        if (!type)
+            continue;
+        assertPng(icon);
+        const head = Buffer.alloc(8);
+        head.write(type, 0, 4, "ascii");
+        head.writeUInt32BE(icon.data.length + 8, 4);
+        chunks.push(head, icon.data);
+    }
+    if (!chunks.length)
+        throw new Error("no icon sizes usable for icns (16, 32, 64, 128, 256, 512, 1024)");
+    const total = chunks.reduce((n, c) => n + c.length, 0) + 8;
+    const header = Buffer.alloc(8);
+    header.write("icns", 0, 4, "ascii");
+    header.writeUInt32BE(total, 4);
+    return Buffer.concat([header, ...chunks]);
+}
+export function readIcoDirectory(ico) {
+    const count = ico.readUInt16LE(4);
+    const out = [];
+    for (let i = 0; i < count; i++) {
+        const at = 6 + i * 16;
+        const w = ico.readUInt8(at);
+        out.push({ size: w === 0 ? 256 : w, bytes: ico.readUInt32LE(at + 8), offset: ico.readUInt32LE(at + 12) });
+    }
+    return out;
+}

package/dist/jsonrpc.js

@@ -0,0 +1,109 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { createInterface } from "node:readline";
+export class MethodNotFound extends Error {
+    method;
+    constructor(method) {
+        super(`Method not found: ${method}`);
+        this.method = method;
+    }
+}
+export class RemoteError extends Error {
+    rpc;
+    method;
+    constructor(rpc, method) {
+        super(`${method} failed: ${rpc.message} (code ${rpc.code})`);
+        this.rpc = rpc;
+        this.method = method;
+    }
+}
+export class JsonRpcPeer {
+    input;
+    handlers;
+    nextId = 1;
+    pending = new Map();
+    closed = false;
+    constructor(input, output, handlers) {
+        this.input = input;
+        this.handlers = handlers;
+        const rl = createInterface({ input: output });
+        rl.on("line", (line) => {
+            void this.onLine(line);
+        });
+    }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error(`connection closed (${method})`));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { method, resolve, reject });
+            this.write({ jsonrpc: "2.0", id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.write({ jsonrpc: "2.0", method, params });
+    }
+    close(reason) {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const [id, p] of this.pending) {
+            this.pending.delete(id);
+            p.reject(new Error(`${p.method}: ${reason}`));
+        }
+    }
+    get isClosed() {
+        return this.closed;
+    }
+    write(message) {
+        if (this.closed)
+            return;
+        this.handlers.onRaw?.("out", message);
+        this.input.write(JSON.stringify(message) + "\n");
+    }
+    async onLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch {
+            this.handlers.onProtocolError?.(`non-JSON line on stdout: ${trimmed.slice(0, 200)}`);
+            return;
+        }
+        this.handlers.onRaw?.("in", msg);
+        if ("method" in msg) {
+            const hasId = "id" in msg && msg.id !== undefined && msg.id !== null;
+            if (hasId) {
+                const id = msg.id;
+                try {
+                    const result = await this.handlers.onRequest(msg.method, msg.params);
+                    this.write({ jsonrpc: "2.0", id, result: result ?? null });
+                }
+                catch (error) {
+                    const rpcError = error instanceof MethodNotFound
+                        ? { code: -32601, message: error.message }
+                        : { code: -32603, message: error instanceof Error ? error.message : String(error) };
+                    this.write({ jsonrpc: "2.0", id, error: rpcError });
+                }
+            }
+            else {
+                this.handlers.onNotification(msg.method, msg.params);
+            }
+            return;
+        }
+        if ("id" in msg) {
+            const p = this.pending.get(msg.id);
+            if (!p) {
+                this.handlers.onProtocolError?.(`response for unknown id ${String(msg.id)}`);
+                return;
+            }
+            this.pending.delete(msg.id);
+            if (msg.error)
+                p.reject(new RemoteError(msg.error, p.method));
+            else
+                p.resolve(msg.result);
+        }
+    }
+}