viberoom 0.2.0

package/dist/launcher.js

@@ -0,0 +1,161 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { existsSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { join, posix, win32 } from "node:path";
+const COMMANDS = new Set(["run", "serve", "start", "stop", "status", "open", "logs", "help"]);
+export function splitCommand(argv) {
+    const first = argv[0];
+    if (first && !first.startsWith("-") && COMMANDS.has(first))
+        return { command: first, rest: argv.slice(1) };
+    return { command: "run", rest: argv };
+}
+export function pidFilePath(dataDir) {
+    return join(dataDir, "hub.pid");
+}
+export function browserProfileDir(dataDir) {
+    return join(dataDir, "browser");
+}
+export function logFilePath(dataDir) {
+    return join(dataDir, "hub.log");
+}
+export function writePidFile(dataDir, record) {
+    writeFileSync(pidFilePath(dataDir), JSON.stringify(record));
+}
+export function readPidFile(dataDir) {
+    try {
+        const raw = readFileSync(pidFilePath(dataDir), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.pid !== "number")
+            return null;
+        return { pid: parsed.pid, port: Number(parsed.port ?? 0), build: String(parsed.build ?? ""), startedAt: Number(parsed.startedAt ?? 0) };
+    }
+    catch {
+        return null;
+    }
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+const LOG_ROTATE_BYTES = 5 * 1024 * 1024;
+export function rotateLog(path, limit = LOG_ROTATE_BYTES) {
+    try {
+        if (!existsSync(path) || statSync(path).size < limit)
+            return false;
+        renameSync(path, `${path}.1`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function tailFile(path, lines) {
+    try {
+        const text = readFileSync(path, "utf8");
+        return text.split(/\r?\n/).filter((l) => l.length).slice(-lines).join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+export function findChromium(env = process.env, platform = process.platform, exists = existsSync) {
+    const candidates = [];
+    const P = platform === "win32" ? win32 : posix;
+    if (platform === "win32") {
+        const roots = [env["ProgramFiles"], env["ProgramFiles(x86)"], env["LOCALAPPDATA"]].filter((r) => !!r);
+        for (const root of roots)
+            candidates.push(P.join(root, "Google", "Chrome", "Application", "chrome.exe"));
+        for (const root of roots)
+            candidates.push(P.join(root, "Microsoft", "Edge", "Application", "msedge.exe"));
+        for (const root of roots)
+            candidates.push(P.join(root, "Chromium", "Application", "chrome.exe"));
+    }
+    else if (platform === "darwin") {
+        candidates.push("/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge", "/Applications/Chromium.app/Contents/MacOS/Chromium", "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser");
+    }
+    else {
+        const dirs = (env.PATH ?? "").split(P.delimiter).filter(Boolean);
+        for (const name of ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser", "microsoft-edge", "brave-browser"]) {
+            for (const dir of dirs)
+                candidates.push(P.join(dir, name));
+        }
+    }
+    return candidates.find((c) => exists(c)) ?? null;
+}
+function findBounds(node) {
+    if (!node || typeof node !== "object")
+        return null;
+    const o = node;
+    if (["left", "top", "right", "bottom"].every((k) => typeof o[k] === "number"))
+        return o;
+    for (const value of Object.values(o)) {
+        const found = findBounds(value);
+        if (found)
+            return found;
+    }
+    return null;
+}
+export function savedWindowPlacement(profileDir) {
+    try {
+        const prefs = JSON.parse(readFileSync(join(profileDir, "Default", "Preferences"), "utf8"));
+        const browser = prefs.browser;
+        const bounds = findBounds(browser?.app_window_placement);
+        if (!bounds)
+            return null;
+        const width = bounds.right - bounds.left;
+        const height = bounds.bottom - bounds.top;
+        if (width < 200 || height < 150)
+            return null;
+        const placement = { left: bounds.left, top: bounds.top, width, height, maximized: !!bounds.maximized };
+        const wa = [bounds.work_area_left, bounds.work_area_top, bounds.work_area_right, bounds.work_area_bottom];
+        if (wa.every((v) => typeof v === "number"))
+            placement.workArea = { left: wa[0], top: wa[1], right: wa[2], bottom: wa[3] };
+        return placement;
+    }
+    catch {
+        return null;
+    }
+}
+export function windowFlags(placement) {
+    const wa = placement.workArea;
+    if (placement.maximized && wa && wa.right - wa.left >= 200 && wa.bottom - wa.top >= 150) {
+        return [`--window-position=${wa.left},${wa.top}`, `--window-size=${wa.right - wa.left},${wa.bottom - wa.top}`];
+    }
+    let { left, top, width, height } = placement;
+    if (wa) {
+        width = Math.min(width, wa.right - wa.left);
+        height = Math.min(height, wa.bottom - wa.top);
+        left = Math.max(wa.left, Math.min(left, wa.right - width));
+        top = Math.max(wa.top, Math.min(top, wa.bottom - height));
+    }
+    return [`--window-position=${left},${top}`, `--window-size=${width},${height}`];
+}
+export function appWindowArgs(url, profileDir, freshProfile, placement = null, platform = process.platform) {
+    const args = [
+        `--app=${url}`,
+        `--user-data-dir=${profileDir}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-background-mode",
+        "--disable-extensions",
+        "--disable-component-extensions-with-background-pages",
+    ];
+    if (placement)
+        args.push(...windowFlags(placement));
+    else if (freshProfile)
+        args.push("--window-size=1500,950");
+    if (platform === "linux")
+        args.push("--class=viberoom");
+    return args;
+}
+export function openUrlCommand(url, platform = process.platform) {
+    if (platform === "win32")
+        return `start "" "${url}"`;
+    if (platform === "darwin")
+        return `open "${url}"`;
+    return `xdg-open "${url}"`;
+}

package/dist/log.js

@@ -0,0 +1,35 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+export class Logger {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    info(message) {
+        process.stderr.write(`[${timestamp()}] [${this.scope}] ${message}\n`);
+    }
+    warn(message) {
+        process.stderr.write(`[${timestamp()}] [${this.scope}] WARN ${message}\n`);
+    }
+    error(message) {
+        process.stderr.write(`[${timestamp()}] [${this.scope}] ERROR ${message}\n`);
+    }
+    child(scope) {
+        return new Logger(`${this.scope}/${scope}`);
+    }
+}
+function timestamp() {
+    return new Date().toISOString().slice(11, 23);
+}
+export class Transcript {
+    path;
+    constructor(directory, name) {
+        mkdirSync(directory, { recursive: true });
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        this.path = join(directory, `${name}-${stamp}.jsonl`);
+    }
+    record(direction, message) {
+        appendFileSync(this.path, JSON.stringify({ t: Date.now(), dir: direction === "out" ? "C->A" : "A->C", msg: message }) + "\n");
+    }
+}

package/dist/main.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { exec, spawn, spawnSync } from "node:child_process";
+import { appendFileSync, closeSync, cpSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Hub } from "./hub.js";
+import { Logger } from "./log.js";
+import { startServer } from "./server.js";
+import { appWindowArgs, savedWindowPlacement, findChromium, isProcessAlive, logFilePath, openUrlCommand, pidFilePath, readPidFile, rotateLog, splitCommand, tailFile, writePidFile, } from "./launcher.js";
+import { aumidSyncScript, installShortcuts, windowsShortcutPaths } from "./shortcuts.js";
+import { runMenu } from "./tui.js";
+function parseArgs(argv) {
+    const { command, rest } = splitCommand(argv);
+    const options = {
+        command,
+        port: 4810,
+        dataDir: process.env.VIBEROOM_DATA_DIR ? resolve(process.env.VIBEROOM_DATA_DIR) : resolve(homedir(), ".viberoom"),
+        name: undefined,
+        open: true,
+        browser: false,
+        menu: true,
+    };
+    for (let i = 0; i < rest.length; i++) {
+        const arg = rest[i];
+        const next = () => {
+            const value = rest[++i];
+            if (value === undefined)
+                throw new Error(`missing value for ${arg}`);
+            return value;
+        };
+        switch (arg) {
+            case "--port":
+                options.port = Number(next());
+                break;
+            case "--name":
+                options.name = next();
+                break;
+            case "--data-dir":
+                options.dataDir = resolve(next());
+                break;
+            case "--open":
+                options.open = true;
+                options.menu = false;
+                break;
+            case "--no-open":
+                options.open = false;
+                options.menu = false;
+                break;
+            case "--browser":
+                options.browser = true;
+                options.menu = false;
+                break;
+            case "-h":
+            case "--help":
+                options.command = "help";
+                break;
+            default:
+                throw new Error(`unknown argument: ${arg}`);
+        }
+    }
+    return options;
+}
+function printHelp() {
+    process.stdout.write(`viberoom: group chat rooms for a human and several coding agents (Agent Client Protocol)
+
+Usage: viberoom [command] [--port 4810] [--data-dir <dir>] [--name Human] [--no-open] [--browser]
+
+Commands
+  (none)       in a terminal: a small menu (desktop icon / app window / browser / run here);
+               with --open, --no-open or --browser, or without a terminal: run the hub in this
+               process and open the window; if a hub is already running, open it (or replace it
+               when this build is newer)
+  start        run the hub hidden in the background (log in <data-dir>/hub.log) and open the window
+  stop         stop the background hub
+  status       show whether a hub is running, its build and address
+  open         open the window of the running hub
+  logs         print the last lines of the background hub's log
+
+Options
+  --port       localhost port for the web UI (default 4810)
+  --data-dir   where settings, rooms, history, skills and transcripts live (default ~/.viberoom, or $VIBEROOM_DATA_DIR)
+  --name       the human's display name (optional; the first start asks in the browser)
+  --no-open    do not open a window
+  --browser    open the default browser instead of a Chromium app window
+`);
+}
+function buildInfo() {
+    const pkg = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+    const built = statSync(fileURLToPath(import.meta.url)).mtime;
+    return { name: pkg.name, version: pkg.version, build: built.toISOString() };
+}
+async function runningInstance(port) {
+    const url = `http://127.0.0.1:${port}/`;
+    try {
+        const res = await fetch(`${url}api/settings`, { signal: AbortSignal.timeout(1500) });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        if (typeof body.humanName !== "string")
+            return null;
+    }
+    catch {
+        return null;
+    }
+    try {
+        const res = await fetch(`${url}api/version`, { signal: AbortSignal.timeout(1500) });
+        if (!res.ok)
+            return { url, build: null };
+        const info = (await res.json());
+        return { url, build: typeof info.build === "string" ? info.build : null };
+    }
+    catch {
+        return { url, build: null };
+    }
+}
+async function waitUntil(check, timeoutMs, stepMs = 250) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await check())
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, stepMs));
+    }
+    return false;
+}
+async function isUp(url) {
+    try {
+        await fetch(`${url}api/settings`, { signal: AbortSignal.timeout(500) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function stopInstance(url, log) {
+    try {
+        await fetch(`${url}api/shutdown`, { method: "POST", signal: AbortSignal.timeout(1500) });
+    }
+    catch (error) {
+        log.warn(`could not ask the running hub to stop: ${String(error)}`);
+        return false;
+    }
+    return waitUntil(async () => !(await isUp(url)), 10_000);
+}
+function migrateLegacyData(dataDir, log) {
+    const legacy = resolve(fileURLToPath(new URL("../data/", import.meta.url)));
+    if (existsSync(join(dataDir, "rooms.json")) || !existsSync(join(legacy, "rooms.json")))
+        return;
+    if (resolve(legacy) === resolve(dataDir))
+        return;
+    mkdirSync(dataDir, { recursive: true });
+    cpSync(legacy, dataDir, { recursive: true });
+    log.info(`copied existing rooms and settings from ${legacy} to ${dataDir} (the old folder is left untouched)`);
+}
+function reapHiddenBrowser(profileDir, log) {
+    if (process.platform !== "win32")
+        return;
+    const needle = profileDir.replace(/'/g, "''");
+    const script = `$ps = Get-CimInstance Win32_Process | Where-Object { $_.Name -eq 'chrome.exe' -and $_.CommandLine -like '*${needle}*' -and $_.CommandLine -notlike '*--type=*' }; foreach ($p in $ps) { $proc = Get-Process -Id $p.ProcessId -ErrorAction SilentlyContinue; if ($proc -and $proc.MainWindowHandle -eq 0) { Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue; "killed $($p.ProcessId)" } elseif ($proc) { "open $($p.ProcessId)" } }`;
+    try {
+        const r = spawnSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { encoding: "utf8", timeout: 10_000, windowsHide: true });
+        for (const line of (r.stdout || "").split(/\r?\n/).filter(Boolean)) {
+            if (line.startsWith("killed"))
+                log.info(`closed a leftover browser process that had no window (pid ${line.slice(7)})`);
+            else if (line.startsWith("open"))
+                log.warn(`the app window is already open (browser pid ${line.slice(5)}); a second window joins it and the saved placement applies only after both are closed`);
+        }
+    }
+    catch {
+    }
+}
+function openWindow(url, options, log) {
+    const chromium = options.browser ? null : findChromium();
+    if (chromium) {
+        const profile = join(options.dataDir, "browser");
+        const fresh = !existsSync(profile);
+        mkdirSync(profile, { recursive: true });
+        reapHiddenBrowser(profile, log);
+        const placement = fresh ? null : savedWindowPlacement(profile);
+        const args = appWindowArgs(url, profile, fresh, placement);
+        const where = placement
+            ? `last seen at ${placement.left},${placement.top} ${placement.width}x${placement.height}${placement.maximized ? " maximized" : ""}${placement.workArea ? ` on the screen ${placement.workArea.left},${placement.workArea.top}-${placement.workArea.right},${placement.workArea.bottom}` : ""}; flags ${args.filter((a) => a.startsWith("--window-")).join(" ")}`
+            : "no saved placement";
+        log.info(`opening the app window with ${chromium}: ${where}`);
+        try {
+            appendFileSync(logFilePath(options.dataDir), `[${new Date().toISOString()}] [launcher] app window: ${where}\n`);
+        }
+        catch {
+        }
+        spawn(chromium, args, { detached: true, stdio: "ignore" }).unref();
+        if (process.platform === "win32") {
+            const shortcuts = windowsShortcutPaths(homedir(), process.env, true).filter((p) => existsSync(p));
+            if (shortcuts.length)
+                spawn("powershell", ["-NoProfile", "-Command", aumidSyncScript(profile, shortcuts)], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+        }
+        return;
+    }
+    log.info("opening the default browser");
+    exec(openUrlCommand(url), () => undefined);
+}
+async function runHub(options, log, info) {
+    const background = options.command === "serve";
+    if (!background) {
+        const running = await runningInstance(options.port);
+        if (running && running.build === info.build) {
+            log.info(`viberoom is already running at ${running.url} (same build); opening it.`);
+            process.stdout.write(`${running.url}\n`);
+            if (options.open)
+                openWindow(running.url, options, log);
+            return;
+        }
+        if (running) {
+            log.info(`an older viberoom build is running at ${running.url}; replacing it with the build from ${info.build}`);
+            if (!(await stopInstance(running.url, log))) {
+                throw new Error(`the older viberoom hub on port ${options.port} did not stop; stop it (viberoom stop, or Ctrl+C in its terminal) and run viberoom again`);
+            }
+        }
+    }
+    migrateLegacyData(options.dataDir, log);
+    const hub = new Hub(options.dataDir, log, options.name);
+    if (options.name && hub.settings.humanName !== options.name)
+        hub.updateSettings({ humanName: options.name });
+    let shuttingDown = false;
+    let server;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        log.info("shutting down: closing agent sessions");
+        await hub.shutdown();
+        server?.close();
+        if (background)
+            rmSync(pidFilePath(options.dataDir), { force: true });
+        process.exit(0);
+    };
+    try {
+        server = await startServer(hub, options.port, log.child("http"), info, () => void shutdown());
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "EADDRINUSE") {
+            throw new Error(`port ${options.port} is taken by another program (not a viberoom hub). Pick another port: viberoom --port 4811`);
+        }
+        throw error;
+    }
+    hub.setHubUrl(server.url);
+    if (background)
+        writePidFile(options.dataDir, { pid: process.pid, port: options.port, build: info.build, startedAt: Date.now() });
+    log.info(`viberoom ${info.version} (build ${info.build}) is open at ${server.url} (data: ${hub.dataDir}; rooms: ${[...hub.rooms.values()].map((r) => r.name).join(", ")})`);
+    process.stdout.write(`${server.url}\n`);
+    if (options.open && !background)
+        openWindow(server.url, options, log);
+    process.on("SIGINT", () => void shutdown());
+    process.on("SIGTERM", () => void shutdown());
+    process.on("SIGHUP", () => void shutdown());
+}
+async function startBackground(options, log, info) {
+    const url = `http://127.0.0.1:${options.port}/`;
+    const running = await runningInstance(options.port);
+    if (running && running.build === info.build) {
+        log.info(`viberoom is already running at ${url} (same build).`);
+        process.stdout.write(`${url}\n`);
+        if (options.open)
+            openWindow(url, options, log);
+        return;
+    }
+    if (running) {
+        log.info(`an older viberoom build is running at ${url}; replacing it with the build from ${info.build}`);
+        if (!(await stopInstance(url, log)))
+            throw new Error(`the older viberoom hub on port ${options.port} did not stop; try: viberoom stop`);
+    }
+    mkdirSync(options.dataDir, { recursive: true });
+    const logPath = logFilePath(options.dataDir);
+    rotateLog(logPath);
+    const fd = openSync(logPath, "a");
+    const args = [fileURLToPath(import.meta.url), "serve", "--port", String(options.port), "--data-dir", options.dataDir, "--no-open"];
+    if (options.name)
+        args.push("--name", options.name);
+    const child = spawn(process.execPath, args, { detached: true, stdio: ["ignore", fd, fd], windowsHide: true });
+    child.unref();
+    closeSync(fd);
+    log.info(`hub started in the background (pid ${child.pid}); log: ${logPath}`);
+    const up = await waitUntil(() => isUp(url), 20_000);
+    if (!up)
+        throw new Error(`the hub did not come up within 20 s; see ${logPath}`);
+    process.stdout.write(`${url}\n`);
+    if (options.open)
+        openWindow(url, options, log);
+}
+async function stopBackground(options, log) {
+    const url = `http://127.0.0.1:${options.port}/`;
+    const record = readPidFile(options.dataDir);
+    if (await isUp(url)) {
+        const ok = await stopInstance(url, log);
+        if (ok) {
+            log.info(`hub on port ${options.port} stopped`);
+            rmSync(pidFilePath(options.dataDir), { force: true });
+            return;
+        }
+    }
+    if (record && isProcessAlive(record.pid)) {
+        log.warn(`the hub did not answer on ${url}; terminating pid ${record.pid}`);
+        try {
+            process.kill(record.pid);
+        }
+        catch (error) {
+            throw new Error(`could not terminate pid ${record.pid}: ${String(error)}`);
+        }
+        rmSync(pidFilePath(options.dataDir), { force: true });
+        return;
+    }
+    rmSync(pidFilePath(options.dataDir), { force: true });
+    log.info("no hub is running");
+}
+async function showStatus(options) {
+    const url = `http://127.0.0.1:${options.port}/`;
+    const running = await runningInstance(options.port);
+    const record = readPidFile(options.dataDir);
+    if (running) {
+        const pid = record && isProcessAlive(record.pid) ? ` (background pid ${record.pid}, started ${new Date(record.startedAt).toLocaleString()})` : " (foreground or another data folder)";
+        process.stdout.write(`running at ${url}${pid}\nbuild: ${running.build ?? "unknown (older build)"}\ndata: ${options.dataDir}\nlog: ${logFilePath(options.dataDir)}\n`);
+    }
+    else {
+        process.stdout.write(`not running on port ${options.port}${record ? ` (stale pid file: ${record.pid})` : ""}\n`);
+        if (record && !isProcessAlive(record.pid))
+            rmSync(pidFilePath(options.dataDir), { force: true });
+    }
+}
+async function main() {
+    const log = new Logger("hub");
+    const options = parseArgs(process.argv.slice(2));
+    const info = buildInfo();
+    switch (options.command) {
+        case "help":
+            printHelp();
+            return;
+        case "start":
+            await startBackground(options, log, info);
+            return;
+        case "stop":
+            await stopBackground(options, log);
+            return;
+        case "status":
+            await showStatus(options);
+            return;
+        case "open": {
+            const url = `http://127.0.0.1:${options.port}/`;
+            if (!(await isUp(url)))
+                throw new Error(`no hub is running on port ${options.port}; start one with: viberoom start`);
+            openWindow(url, options, log);
+            return;
+        }
+        case "logs": {
+            const path = logFilePath(options.dataDir);
+            process.stdout.write(`${path}\n${tailFile(path, 60)}\n`);
+            return;
+        }
+        case "run":
+            if (options.menu) {
+                const choice = await runMenu("viberoom: rooms for you and your coding agents");
+                if (choice === "quit")
+                    return;
+                if (choice === "window" || choice === "browser") {
+                    options.browser = choice === "browser";
+                    await startBackground(options, log, info);
+                    return;
+                }
+                if (choice === "shortcut") {
+                    const pkg = JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8"));
+                    const result = installShortcuts({ root: fileURLToPath(new URL("..", import.meta.url)), dataDir: options.dataDir, node: process.execPath, version: pkg.version, desktop: true });
+                    for (const file of result.files)
+                        process.stdout.write(`wrote: ${file}\n`);
+                    for (const note of result.notes)
+                        process.stdout.write(`${note}\n`);
+                    return;
+                }
+            }
+            await runHub(options, log, info);
+            return;
+        case "serve":
+            await runHub(options, log, info);
+            return;
+    }
+}
+main().catch((error) => {
+    process.stderr.write(`viberoom: ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});