viberoom 0.2.0

package/dist/skills.js

@@ -0,0 +1,344 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+export const SKILL_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+export const SKILL_FILE = "SKILL.md";
+export const BUILTIN_AUTHOR = "viberoom";
+export const HUMAN_AUTHOR = "human";
+const DESCRIPTION_MAX = 300;
+const DESCRIPTION_MIN_USEFUL = 15;
+const BODY_MAX = 20_000;
+const KNOWN_FIELDS = new Set([
+    "name",
+    "description",
+    "argument-hint",
+    "user-invocable",
+    "disable-agent-invocation",
+    "author",
+    "created",
+    "reviewed",
+    "draft",
+    "metadata",
+    "license",
+    "compatibility",
+    "when_to_use",
+]);
+export function lintSkill(input) {
+    const errors = [];
+    const warnings = [];
+    const name = input.name.trim();
+    const description = input.description.trim();
+    const body = input.body.replace(/\r\n/g, "\n").trim();
+    const hint = (input.argumentHint ?? "").trim();
+    if (!SKILL_NAME_PATTERN.test(name))
+        errors.push({ code: "name-invalid", message: `name "${name}" must be 1-32 letters, digits, _ or -` });
+    if (input.folder && name.toLowerCase() !== input.folder.toLowerCase()) {
+        errors.push({ code: "name-folder-mismatch", message: `name "${name}" differs from the folder "${input.folder}"` });
+    }
+    if (!description)
+        errors.push({ code: "description-missing", message: "description is required: it is what tells an agent when to use the skill" });
+    else if (description.length > DESCRIPTION_MAX)
+        errors.push({ code: "description-too-long", message: `description must be at most ${DESCRIPTION_MAX} characters` });
+    else if (description.length < DESCRIPTION_MIN_USEFUL || description.toLowerCase() === name.toLowerCase()) {
+        warnings.push({ code: "description-thin", message: "description should say what the skill does and when to use it, not just its name" });
+    }
+    if (!body)
+        errors.push({ code: "body-empty", message: "the instructions are empty" });
+    else if (body.length > BODY_MAX)
+        errors.push({ code: "body-too-long", message: `the instructions must be at most ${BODY_MAX} characters` });
+    if (/\[skill:/i.test(body) || /<\/?skill[\s>]/i.test(body)) {
+        errors.push({ code: "body-contains-delivery-syntax", message: "the instructions must not contain [skill:…] or <skill> tags (they are the hub's delivery syntax)" });
+    }
+    const usesArguments = /(^|[^\\])\$ARGUMENTS/.test(body);
+    if (usesArguments && !hint)
+        warnings.push({ code: "arguments-without-hint", message: "the instructions use $ARGUMENTS but there is no argument hint for the / menu" });
+    if (!usesArguments && hint)
+        warnings.push({ code: "hint-without-arguments", message: "there is an argument hint but the instructions never use $ARGUMENTS" });
+    for (const field of input.unknownFields ?? [])
+        warnings.push({ code: "unknown-field", message: `unknown frontmatter field "${field}" is ignored` });
+    return { errors, warnings };
+}
+export const SKILL_WRITER = {
+    name: "skill-writer",
+    description: "How to write a good skill for this library. Load it before creating or updating a skill with create_skill / update_skill.",
+    argumentHint: "",
+    body: [
+        "A skill is a reusable set of instructions for one kind of task. Another agent (or you, later, in another room) will get only this text when the skill is invoked, so it must stand on its own.",
+        "",
+        "Write it like this:",
+        "- name: short, lowercase, hyphenated (e.g. pr-review, daily-summary). It becomes the /command.",
+        "- description: one or two sentences that say WHAT the skill does and WHEN to use it. This is the only thing agents see before loading it, so it must let them decide (e.g. \"Review a pull request for correctness and post findings as a numbered list. Use when someone asks for a code review.\").",
+        "- instructions: imperative, concrete steps or a format. Say what the reply should contain, in what order, how long. Include an example when the format is non-obvious. Write \\$ARGUMENTS where the caller's text (what follows /name) belongs; give an argument hint like [PR number] when you use it. To mention the placeholder without filling it in, put a backslash before it.",
+        "- Do not put chat greetings, room rules or secrets in a skill, and do not write the hub's own delivery markers (the bracketed skill marker or skill tags) in it.",
+        "- Keep it under ~300 words; put long reference material in separate files in the skill's folder instead.",
+        "",
+        "Before creating: check that no existing skill already covers the task (your brief lists the skills you have). Prefer updating an agent-made skill over creating a near-duplicate.",
+        "After creating: attach it to yourself (attach_skill) if you will use it, and to other agents only when they need it; say in the room what you created and why.",
+    ].join("\n"),
+    userInvocable: true,
+    agentInvocable: true,
+    author: BUILTIN_AUTHOR,
+    reviewed: true,
+    draft: false,
+};
+export function parseFrontmatter(text) {
+    const normalized = text.replace(/^/, "").replace(/\r\n/g, "\n");
+    const match = normalized.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+    if (!match)
+        return { meta: {}, body: normalized };
+    const meta = {};
+    for (const rawLine of match[1].split("\n")) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const colon = line.indexOf(":");
+        if (colon <= 0)
+            continue;
+        const key = line.slice(0, colon).trim();
+        let value = line.slice(colon + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+            value = value.slice(1, -1);
+        meta[key] = value;
+    }
+    return { meta, body: match[2] };
+}
+export function renderFrontmatter(meta) {
+    const lines = ["---"];
+    for (const [key, value] of Object.entries(meta)) {
+        if (value === undefined || value === "")
+            continue;
+        const text = typeof value === "boolean" ? String(value) : /[:#"'\n]/.test(value) ? JSON.stringify(value) : value;
+        lines.push(`${key}: ${text}`);
+    }
+    lines.push("---");
+    return lines.join("\n");
+}
+function listExtraFiles(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isFile() && d.name !== SKILL_FILE)
+            .map((d) => join(dir, d.name))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function parseBool(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    const v = value.trim().toLowerCase();
+    if (v === "true" || v === "yes")
+        return true;
+    if (v === "false" || v === "no")
+        return false;
+    return fallback;
+}
+export function parseSkillInvocation(text) {
+    const match = text.match(/^(?:@[\p{L}\p{N}][\p{L}\p{N}_-]*\s+)*\/([A-Za-z0-9][A-Za-z0-9_-]{0,31})(?:\s+([\s\S]*))?$/u);
+    if (!match)
+        return null;
+    return { name: match[1], args: (match[2] ?? "").trim() };
+}
+export function renderSkillBody(body, args) {
+    const trimmedArgs = args.trim();
+    return body
+        .replace(/\\\$ARGUMENTS|\$ARGUMENTS/g, (m) => (m.startsWith("\\") ? "$ARGUMENTS" : trimmedArgs))
+        .replace(/\r\n/g, "\n")
+        .trim();
+}
+export function isBuiltinSkill(name) {
+    return name.trim().toLowerCase() === SKILL_WRITER.name;
+}
+export class SkillLibrary {
+    dir;
+    log;
+    cache = new Map();
+    constructor(dir, log) {
+        this.dir = resolve(dir);
+        this.log = log;
+        mkdirSync(this.dir, { recursive: true });
+    }
+    list() {
+        const out = [];
+        let entries = [];
+        try {
+            entries = readdirSync(this.dir, { withFileTypes: true })
+                .filter((d) => d.isDirectory())
+                .map((d) => d.name)
+                .sort((a, b) => a.localeCompare(b));
+        }
+        catch (error) {
+            this.log.warn(`skills folder unreadable: ${String(error)}`);
+            return out;
+        }
+        const seen = new Set();
+        for (const folder of entries) {
+            const skill = this.load(folder);
+            if (!skill)
+                continue;
+            seen.add(folder);
+            const { body: _body, ...meta } = skill;
+            out.push(meta);
+        }
+        for (const key of [...this.cache.keys()])
+            if (!seen.has(key))
+                this.cache.delete(key);
+        return out;
+    }
+    get(name) {
+        if (!SKILL_NAME_PATTERN.test(name))
+            return undefined;
+        const folder = this.folderFor(name);
+        return folder ? this.load(folder) : undefined;
+    }
+    lint(draft) {
+        return lintSkill({ name: draft.name, description: draft.description, argumentHint: draft.argumentHint, body: draft.body });
+    }
+    save(draft) {
+        const name = draft.name.trim();
+        if (isBuiltinSkill(name) && draft.author !== BUILTIN_AUTHOR)
+            throw new Error(`${name} is built into viberoom and read-only; create your own skill instead`);
+        const description = draft.description.trim();
+        const body = draft.body.replace(/\r\n/g, "\n").trim();
+        const lint = this.lint({ ...draft, name, description, body });
+        if (lint.errors.length)
+            throw new Error(lint.errors.map((e) => e.message).join("; "));
+        const existingFolder = this.folderFor(name);
+        const existing = existingFolder ? this.load(existingFolder) : undefined;
+        const folder = existingFolder ?? name;
+        const dir = join(this.dir, folder);
+        mkdirSync(dir, { recursive: true });
+        const author = draft.author ?? existing?.author ?? HUMAN_AUTHOR;
+        const created = existing?.created || new Date().toISOString();
+        const reviewed = draft.reviewed ?? (author === HUMAN_AUTHOR || author === BUILTIN_AUTHOR ? true : (existing?.reviewed ?? false));
+        const isDraft = draft.draft ?? (existing?.draft ?? false);
+        const text = `${renderFrontmatter({
+            name,
+            description,
+            "argument-hint": draft.argumentHint?.trim() || undefined,
+            "user-invocable": draft.userInvocable === false ? false : undefined,
+            "disable-agent-invocation": draft.agentInvocable === false ? true : undefined,
+            author: author === HUMAN_AUTHOR ? undefined : author,
+            created,
+            reviewed: reviewed ? undefined : false,
+            draft: isDraft ? true : undefined,
+        })}\n\n${body}\n`;
+        writeFileSync(join(dir, SKILL_FILE), text);
+        this.cache.delete(folder);
+        const skill = this.load(folder);
+        if (!skill)
+            throw new Error("the skill could not be read back");
+        this.log.info(`skill "${name}" saved (${skill.file}; author ${author}${isDraft ? "; draft" : ""})`);
+        return skill;
+    }
+    approve(name) {
+        const skill = this.get(name);
+        if (!skill)
+            throw new Error(`no such skill: ${name}`);
+        return this.save({
+            name: skill.name,
+            description: skill.description,
+            argumentHint: skill.argumentHint,
+            body: skill.body,
+            userInvocable: skill.userInvocable,
+            agentInvocable: skill.agentInvocable,
+            author: skill.author,
+            reviewed: true,
+            draft: false,
+        });
+    }
+    seedBuiltins() {
+        for (const builtin of [SKILL_WRITER]) {
+            const folder = this.folderFor(builtin.name);
+            const current = folder ? this.load(folder) : undefined;
+            if (current && current.description === builtin.description && current.body === builtin.body && (current.argumentHint ?? "") === (builtin.argumentHint ?? ""))
+                continue;
+            this.save(builtin);
+            if (current)
+                this.log.info(`built-in skill "${builtin.name}" updated to the shipped text`);
+        }
+    }
+    remove(name) {
+        if (isBuiltinSkill(name))
+            throw new Error(`${name.trim()} is built into viberoom and cannot be deleted; detach it from a vibemate if it should not use it`);
+        const folder = this.folderFor(name);
+        if (!folder)
+            throw new Error(`no such skill: ${name}`);
+        rmSync(join(this.dir, folder), { recursive: true, force: true });
+        this.cache.delete(folder);
+        this.log.info(`skill "${name}" removed`);
+    }
+    folderFor(name) {
+        if (existsSync(join(this.dir, name, SKILL_FILE)))
+            return name;
+        const lower = name.toLowerCase();
+        try {
+            for (const d of readdirSync(this.dir, { withFileTypes: true })) {
+                if (d.isDirectory() && d.name.toLowerCase() === lower && existsSync(join(this.dir, d.name, SKILL_FILE)))
+                    return d.name;
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    load(folder) {
+        const dir = join(this.dir, folder);
+        const file = join(dir, SKILL_FILE);
+        let mtime;
+        try {
+            mtime = statSync(file).mtimeMs;
+        }
+        catch {
+            return undefined;
+        }
+        const cached = this.cache.get(folder);
+        if (cached && cached.mtime === mtime) {
+            cached.skill.extraFiles = listExtraFiles(dir);
+            return cached.skill;
+        }
+        let text;
+        try {
+            text = readFileSync(file, "utf8");
+        }
+        catch (error) {
+            this.log.warn(`skill ${folder}: unreadable (${String(error)})`);
+            return undefined;
+        }
+        const { meta, body } = parseFrontmatter(text);
+        const name = (meta.name ?? folder).trim();
+        const description = (meta.description ?? "").trim();
+        const argumentHint = (meta["argument-hint"] ?? "").trim();
+        const lint = lintSkill({
+            name,
+            folder,
+            description,
+            argumentHint,
+            body,
+            unknownFields: Object.keys(meta).filter((k) => !KNOWN_FIELDS.has(k)),
+        });
+        const extraFiles = listExtraFiles(dir);
+        const author = (meta.author ?? "").trim() || HUMAN_AUTHOR;
+        const skill = {
+            name,
+            description: description.slice(0, DESCRIPTION_MAX),
+            argumentHint,
+            userInvocable: parseBool(meta["user-invocable"], true),
+            agentInvocable: !parseBool(meta["disable-agent-invocation"], false),
+            author,
+            created: (meta.created ?? "").trim(),
+            reviewed: parseBool(meta.reviewed, true),
+            draft: parseBool(meta.draft, false),
+            dir,
+            file,
+            extraFiles,
+            mtime,
+            problems: lint.errors.map((e) => e.message),
+            warnings: lint.warnings.map((w) => w.message),
+            body: body.replace(/\r\n/g, "\n").trim(),
+        };
+        this.cache.set(folder, { mtime, skill });
+        return skill;
+    }
+}

package/dist/tui.js

@@ -0,0 +1,109 @@
+export const MENU = [
+    { id: "shortcut", label: "Install the desktop icon", hint: "Start Menu and Desktop entry that opens the app window" },
+    { id: "window", label: "Open in the app window", hint: "the hub in the background, a Chromium window of its own" },
+    { id: "browser", label: "Open in your browser", hint: "the hub in the background, a tab in your default browser" },
+    { id: "terminal", label: "Run here, in this terminal", hint: "the hub in the foreground with its log; Ctrl+C stops it" },
+    { id: "quit", label: "Quit", hint: "" },
+];
+export const QUESTION = "What would you like to do?";
+export function decodeKey(data) {
+    const s = data.toString();
+    if (s === "\x1b[A" || s === "\x1bOA" || s === "k")
+        return { key: "up" };
+    if (s === "\x1b[B" || s === "\x1bOB" || s === "j")
+        return { key: "down" };
+    if (s === "\r" || s === "\n" || s === " ")
+        return { key: "enter" };
+    if (s === "\x1b" || s === "q" || s === "\x03" || s === "\x04")
+        return { key: "escape" };
+    if (/^[1-9]$/.test(s))
+        return { key: "digit", digit: Number(s) };
+    return null;
+}
+export function reduceMenu(state, key, digit, items = MENU) {
+    const n = items.length;
+    switch (key) {
+        case "up":
+            return { index: (state.index - 1 + n) % n };
+        case "down":
+            return { index: (state.index + 1) % n };
+        case "enter":
+            return { index: state.index, done: items[state.index].id };
+        case "escape":
+            return { index: state.index, done: "quit" };
+        case "digit":
+            if (digit === undefined || digit < 1 || digit > n)
+                return state;
+            return { index: digit - 1, done: items[digit - 1].id };
+    }
+}
+export function unicodeSupported(env = process.env, platform = process.platform) {
+    if (platform !== "win32")
+        return env.TERM !== "linux";
+    return Boolean(env.WT_SESSION || env.TERMINUS_SUBLIME || env.ConEmuTask === "{cmd::Cmder}" || env.TERM_PROGRAM === "Terminus-Sublime" || env.TERM_PROGRAM === "vscode" || env.TERM === "xterm-256color" || env.TERM === "alacritty" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm");
+}
+const GLYPHS = {
+    unicode: { top: "┌", bar: "│", bottom: "└", active: "◆", done: "◇", on: "●", off: "○" },
+    ascii: { top: "+", bar: "|", bottom: "+", active: "*", done: "o", on: "(*)", off: "( )" },
+};
+const ESC = "\x1b[";
+const paint = (on, code, text) => (on ? `${ESC}${code}m${text}${ESC}0m` : text);
+export function renderMenu(state, title, opts, items = MENU) {
+    const g = opts.unicode ? GLYPHS.unicode : GLYPHS.ascii;
+    const dim = (t) => paint(opts.color, "2", t);
+    const columns = Math.max(40, opts.columns ?? 80);
+    const lines = [`${dim(g.top)}  ${paint(opts.color, "1", title)}`, dim(g.bar), `${paint(opts.color, "36", g.active)}  ${QUESTION}`];
+    items.forEach((item, i) => {
+        const current = i === state.index;
+        const dot = current ? paint(opts.color, "32", g.on) : dim(g.off);
+        const label = current ? paint(opts.color, "1", item.label) : item.label;
+        lines.push(`${paint(opts.color, "36", g.bar)}  ${dot} ${label}`);
+    });
+    const hint = items[state.index].hint || "Enter to choose, 1-5 to jump, q to quit";
+    lines.push(paint(opts.color, "36", g.bar), `${paint(opts.color, "36", g.bottom)}  ${dim(hint.slice(0, columns - 4))}`);
+    return lines.join("\n") + "\n";
+}
+export function renderDone(choice, title, opts, items = MENU) {
+    const g = opts.unicode ? GLYPHS.unicode : GLYPHS.ascii;
+    const dim = (t) => paint(opts.color, "2", t);
+    const label = items.find((i) => i.id === choice)?.label ?? choice;
+    return [`${dim(g.top)}  ${paint(opts.color, "1", title)}`, dim(g.bar), `${paint(opts.color, "32", g.done)}  ${QUESTION}`, `${dim(g.bar)}  ${dim(label)}`, dim(g.bar), ""].join("\n");
+}
+export function menuLineCount(items = MENU) {
+    return items.length + 5;
+}
+export function runMenu(title, stdin = process.stdin, stdout = process.stdout) {
+    if (!stdin.isTTY || !stdout.isTTY || typeof stdin.setRawMode !== "function")
+        return Promise.resolve(null);
+    const opts = { color: !process.env.NO_COLOR, unicode: unicodeSupported(), columns: stdout.columns };
+    return new Promise((resolve) => {
+        let state = { index: 0 };
+        const clear = () => {
+            stdout.write(`${ESC}${menuLineCount()}A${ESC}0J`);
+        };
+        const finish = (choice) => {
+            stdin.off("data", onData);
+            stdin.setRawMode(false);
+            stdin.pause();
+            clear();
+            stdout.write(renderDone(choice, title, opts));
+            resolve(choice);
+        };
+        const onData = (data) => {
+            const decoded = decodeKey(data);
+            if (!decoded)
+                return;
+            state = reduceMenu(state, decoded.key, decoded.digit);
+            if (state.done)
+                finish(state.done);
+            else {
+                clear();
+                stdout.write(renderMenu(state, title, { ...opts, columns: stdout.columns }));
+            }
+        };
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        stdout.write(renderMenu(state, title, opts));
+    });
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "viberoom",
+  "version": "0.2.0",
+  "description": "viberoom: group chat rooms for a human and several coding agents over the Agent Client Protocol",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "bin": {
+    "viberoom": "dist/main.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/main.js",
+    "dev": "npm run build && node dist/main.js --open",
+    "install:global": "node scripts/install.mjs",
+    "update": "node scripts/update.mjs",
+    "start:bg": "node dist/main.js start",
+    "icons": "node scripts/render-icon.mjs",
+    "prepack": "npm run build"
+  },
+  "files": [
+    "dist",
+    "ui",
+    "assets",
+    "scripts",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@agentclientprotocol/claude-agent-acp": "0.73.0",
+    "@agentclientprotocol/codex-acp": "^1.8.0",
+    "mermaid": "^11.17.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "typescript": "^5.9.0"
+  },
+  "license": "AGPL-3.0-or-later",
+  "author": "Todor Rusev <todor.rosenov.rusev@gmail.com>",
+  "keywords": [
+    "agents",
+    "acp",
+    "agent-client-protocol",
+    "chat",
+    "claude",
+    "codex",
+    "gemini",
+    "cursor",
+    "opencode",
+    "copilot"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/todor-rusev/viberoom.git"
+  },
+  "homepage": "https://github.com/todor-rusev/viberoom#readme",
+  "bugs": {
+    "url": "https://github.com/todor-rusev/viberoom/issues"
+  }
+}

package/scripts/install.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const args = new Set(process.argv.slice(2));
+const dataDir = process.env.VIBEROOM_DATA_DIR ? resolve(process.env.VIBEROOM_DATA_DIR) : join(homedir(), ".viberoom");
+const isWin = process.platform === "win32";
+
+function run(cmd, cmdArgs, opts = {}) {
+  console.log(`> ${cmd} ${cmdArgs.join(" ")}`);
+  const r = isWin && cmd === "npm" ? spawnSync(`npm ${cmdArgs.join(" ")}`, { cwd: root, stdio: "inherit", shell: true, ...opts }) : spawnSync(cmd, cmdArgs, { cwd: root, stdio: "inherit", ...opts });
+  if (r.status !== 0) throw new Error(`${cmd} ${cmdArgs.join(" ")} failed with exit code ${r.status}`);
+}
+
+run("npm", [args.has("--clean") && existsSync(join(root, "package-lock.json")) ? "ci" : "install", "--no-audit", "--no-fund"]);
+run("npm", ["run", "build"]);
+
+if (args.has("--global")) run("npm", ["install", "-g", ".", "--no-audit", "--no-fund"]);
+else run("npm", ["link", "--no-audit", "--no-fund"]);
+
+if (!args.has("--no-shortcuts")) {
+  const { installShortcuts } = await import(pathToFileURL(join(root, "dist", "shortcuts.js")).href);
+  const { version } = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const result = installShortcuts({ root, dataDir, node: process.execPath, version, desktop: args.has("--desktop") });
+  for (const file of result.files) console.log(`wrote: ${file}`);
+  for (const note of result.notes) console.log(note);
+}
+
+console.log("\nviberoom is installed. Try: viberoom   (a small menu),  viberoom start   (hidden hub + app window),  viberoom status,  viberoom stop");

package/scripts/render-icon.mjs

@@ -0,0 +1,84 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const { findChromium } = await import(pathToFileURL(join(root, "dist", "launcher.js")).href);
+const { packIcns, packIco } = await import(pathToFileURL(join(root, "dist", "icons.js")).href);
+
+const chrome = process.env.CHROME || findChromium();
+if (!chrome) throw new Error("no Chromium browser found; set CHROME=<path to chrome.exe>");
+const master = join(root, "assets", "icon-master.png");
+const hasMaster = existsSync(master);
+const svg = hasMaster ? "" : readFileSync(join(root, "assets", "icon-vector.svg"), "utf8");
+const sizes = [16, 32, 48, 64, 128, 256, 512];
+const port = 9360 + Math.floor(Math.random() * 30);
+const profile = join(tmpdir(), `viberoom-icon-${process.pid}`);
+mkdirSync(profile, { recursive: true });
+const browser = spawn(chrome, ["--headless=new", "--disable-gpu", "--no-first-run", `--remote-debugging-port=${port}`, `--user-data-dir=${profile}`, "--window-size=600,600", "about:blank"], { stdio: "ignore" });
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function targets() {
+  for (let i = 0; i < 40; i++) {
+    try {
+      return await (await fetch(`http://127.0.0.1:${port}/json`)).json();
+    } catch {
+      await sleep(250);
+    }
+  }
+  throw new Error("chrome did not start");
+}
+
+try {
+  const page = (await targets()).find((t) => t.type === "page");
+  const ws = new WebSocket(page.webSocketDebuggerUrl);
+  await new Promise((r) => (ws.onopen = r));
+  let nextId = 1;
+  const pending = new Map();
+  ws.onmessage = (ev) => {
+    const msg = JSON.parse(ev.data);
+    if (msg.id && pending.has(msg.id)) {
+      pending.get(msg.id)(msg);
+      pending.delete(msg.id);
+    }
+  };
+  const send = (method, params = {}) =>
+    new Promise((resolve) => {
+      const id = nextId++;
+      pending.set(id, resolve);
+      ws.send(JSON.stringify({ id, method, params }));
+    });
+  await send("Page.enable");
+  await send("Emulation.setDefaultBackgroundColorOverride", { color: { r: 0, g: 0, b: 0, a: 0 } });
+  const icons = [];
+  await send("Emulation.setDeviceMetricsOverride", { width: 600, height: 600, deviceScaleFactor: 1, mobile: false });
+  const pageFile = join(profile, "render.html");
+  for (const size of sizes) {
+    const body = hasMaster
+      ? `<img src="${pathToFileURL(master).href}" style="display:block;width:${size}px;height:${size}px;border-radius:${(size * 0.21).toFixed(2)}px">`
+      : svg.replace(/width="256" height="256"/, `width="${size}" height="${size}"`);
+    const html = `<!doctype html><html><head><style>html,body{margin:0;background:transparent;overflow:hidden}svg,img{display:block}</style></head><body>${body}</body></html>`;
+    writeFileSync(pageFile, html);
+    await send("Page.navigate", { url: pathToFileURL(pageFile).href });
+    await sleep(hasMaster ? 700 : 300);
+    const shot = await send("Page.captureScreenshot", { format: "png", clip: { x: 0, y: 0, width: size, height: size, scale: 1 }, fromSurface: true });
+    const data = Buffer.from(shot.result.data, "base64");
+    writeFileSync(join(root, "assets", `icon-${size}.png`), data);
+    icons.push({ size, data });
+    console.log(`icon-${size}.png ${data.length} bytes`);
+  }
+  writeFileSync(join(root, "assets", "icon.ico"), packIco(icons.filter((i) => i.size <= 256)));
+  writeFileSync(join(root, "assets", "icon.icns"), packIcns(icons));
+  const svgOut = hasMaster
+    ? `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" width="256" height="256"><image href="data:image/png;base64,${icons.find((i) => i.size === 256).data.toString("base64")}" width="256" height="256"/></svg>\n`
+    : svg;
+  writeFileSync(join(root, "assets", "icon.svg"), svgOut);
+  console.log("icon.ico and icon.icns written");
+  ws.close();
+} finally {
+  if (process.platform === "win32") spawnSync("powershell", ["-NoProfile", "-Command", `Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'chrome.exe' -and $_.CommandLine -like '*viberoom-icon-${process.pid}*' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`], { stdio: "ignore" });
+  else browser.kill();
+}

package/scripts/update.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const args = new Set(process.argv.slice(2));
+const isWin = process.platform === "win32";
+const main = join(root, "dist", "main.js");
+
+function run(cmd, cmdArgs, opts = {}) {
+  console.log(`> ${cmd} ${cmdArgs.join(" ")}`);
+  const r = isWin && cmd === "npm" ? spawnSync(`npm ${cmdArgs.join(" ")}`, { cwd: root, stdio: "inherit", shell: true, ...opts }) : spawnSync(cmd, cmdArgs, { cwd: root, stdio: "inherit", ...opts });
+  if (r.status !== 0) throw new Error(`${cmd} ${cmdArgs.join(" ")} failed with exit code ${r.status}`);
+}
+
+run("npm", [args.has("--clean") && existsSync(join(root, "package-lock.json")) ? "ci" : "install", "--no-audit", "--no-fund"]);
+run("npm", ["run", "build"]);
+
+if (!args.has("--no-restart")) {
+  const status = spawnSync(process.execPath, [main, "status"], { encoding: "utf8" });
+  if (/running/.test(status.stdout || "")) {
+    console.log("a hub is running: replacing it with the new build (background, no window)");
+    run(process.execPath, [main, "start", "--no-open"]);
+  } else console.log("no hub running; start one with: viberoom start");
+}
+console.log("\nviberoom is up to date.");