viberoom 0.2.0

package/dist/server.js

@@ -0,0 +1,433 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { existsSync as fileExists } from "node:fs";
+import { classifyOpenTarget, describeOpen, detectEditor, editorCommand, isExecutablePath, openCommand } from "./open.js";
+let editorFound;
+function currentEditor() {
+    if (editorFound === undefined)
+        editorFound = detectEditor(process.env, process.platform, fileExists);
+    return editorFound;
+}
+const STATIC_FILES = {
+    "/": { file: "index.html", type: "text/html; charset=utf-8" },
+    "/index.html": { file: "index.html", type: "text/html; charset=utf-8" },
+    "/app.js": { file: "app.js", type: "text/javascript; charset=utf-8" },
+    "/avatars.js": { file: "avatars.js", type: "text/javascript; charset=utf-8" },
+    "/icons.js": { file: "icons.js", type: "text/javascript; charset=utf-8" },
+    "/theme.css": { file: "theme.css", type: "text/css; charset=utf-8" },
+    "/app.css": { file: "app.css", type: "text/css; charset=utf-8" },
+    "/styleguide": { file: "styleguide.html", type: "text/html; charset=utf-8" },
+    "/manifest.json": { file: "manifest.json", type: "application/manifest+json; charset=utf-8" },
+    "/icon.svg": { file: "icon.svg", type: "image/svg+xml", dir: "assets" },
+    "/icon-256.png": { file: "icon-256.png", type: "image/png", dir: "assets" },
+    "/icon-512.png": { file: "icon-512.png", type: "image/png", dir: "assets" },
+    "/favicon.ico": { file: "icon.ico", type: "image/x-icon", dir: "assets" },
+    "/vendor-icons/claude.svg": { file: "vendors/claude.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor-icons/codex.svg": { file: "vendors/codex.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor-icons/gemini.svg": { file: "vendors/gemini.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor-icons/cursor.svg": { file: "vendors/cursor.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor-icons/opencode.svg": { file: "vendors/opencode.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor-icons/copilot.svg": { file: "vendors/copilot.svg", type: "image/svg+xml", dir: "assets" },
+    "/vendor/mermaid.min.js": { file: "mermaid/dist/mermaid.min.js", type: "text/javascript; charset=utf-8", dir: "node_modules" },
+};
+export function startServer(hub, port, log, info, onShutdownRequest) {
+    const uiDir = fileURLToPath(new URL("../ui/", import.meta.url));
+    const assetsDir = fileURLToPath(new URL("../assets/", import.meta.url));
+    const modulesDir = fileURLToPath(new URL("../node_modules/", import.meta.url));
+    const staticDir = (dir) => (dir === "assets" ? assetsDir : dir === "node_modules" ? modulesDir : uiDir);
+    const clients = new Set();
+    const snapshot = () => ({ ...hub.snapshot(), version: info });
+    const broadcast = (event) => {
+        const payload = `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
+        for (const res of clients)
+            res.write(payload);
+    };
+    hub.on("event", broadcast);
+    const heartbeat = setInterval(() => {
+        for (const res of clients)
+            res.write(": ping\n\n");
+    }, 20_000);
+    const server = createServer(async (req, res) => {
+        try {
+            await handle(req, res);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.warn(`${req.method} ${req.url}: ${message}`);
+            if (!res.headersSent)
+                sendJson(res, 400, { error: message });
+            else
+                res.end();
+        }
+    });
+    async function handle(req, res) {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        const path = url.pathname;
+        const font = req.method === "GET" && path.match(/^\/fonts\/([a-z0-9-]+\.(woff2|css))$/i);
+        if (font) {
+            try {
+                const body = await readFile(`${uiDir}fonts/${font[1]}`);
+                res.writeHead(200, { "Content-Type": font[2].toLowerCase() === "css" ? "text/css; charset=utf-8" : "font/woff2", "Cache-Control": "public, max-age=86400" });
+                res.end(body);
+            }
+            catch {
+                sendJson(res, 404, { error: "no such font" });
+            }
+            return;
+        }
+        if (req.method === "GET" && STATIC_FILES[path]) {
+            const entry = STATIC_FILES[path];
+            const body = await readFile(staticDir(entry.dir) + entry.file);
+            res.writeHead(200, { "Content-Type": entry.type, "Cache-Control": entry.dir === "ui" || !entry.dir ? "no-cache" : "public, max-age=3600" });
+            res.end(body);
+            return;
+        }
+        if (req.method === "GET" && path === "/events") {
+            res.writeHead(200, {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            res.write(`event: snapshot\ndata: ${JSON.stringify({ type: "snapshot", snapshot: snapshot() })}\n\n`);
+            clients.add(res);
+            req.on("close", () => clients.delete(res));
+            return;
+        }
+        if (req.method === "GET" && path === "/api/editor") {
+            sendJson(res, 200, { editor: currentEditor(), settings: hub.settings.editor });
+            return;
+        }
+        if (req.method === "GET" && path === "/api/state") {
+            sendJson(res, 200, snapshot());
+            return;
+        }
+        if (req.method === "GET" && path === "/api/version") {
+            sendJson(res, 200, info);
+            return;
+        }
+        if (req.method === "GET" && path === "/api/skills") {
+            sendJson(res, 200, { skills: hub.listSkills() });
+            return;
+        }
+        const skillGet = req.method === "GET" && path.match(/^\/api\/skills\/([^/]+)$/);
+        if (skillGet) {
+            const skill = hub.skills.get(decodeURIComponent(skillGet[1]));
+            if (!skill) {
+                sendJson(res, 404, { error: "no such skill" });
+                return;
+            }
+            sendJson(res, 200, { skill });
+            return;
+        }
+        if (req.method === "GET" && path === "/api/mcp/skill") {
+            const target = hub.resolveMcpToken(url.searchParams.get("token") ?? "");
+            if (!target) {
+                sendJson(res, 403, { error: "unknown skills token (the session it belonged to is gone)" });
+                return;
+            }
+            const loaded = target.room.loadSkillForAgent(target.participantId, url.searchParams.get("name") ?? "");
+            sendJson(res, 200, loaded);
+            return;
+        }
+        if (req.method === "GET" && path === "/api/settings") {
+            sendJson(res, 200, hub.settings);
+            return;
+        }
+        const recipeOptions = req.method === "GET" && path.match(/^\/api\/recipes\/([^/]+)\/options$/);
+        if (recipeOptions) {
+            const anyRoom = [...hub.rooms.values()][0];
+            if (!anyRoom)
+                throw new Error("create a room first");
+            const info = await anyRoom.discoverOptions(decodeURIComponent(recipeOptions[1]), url.searchParams.get("refresh") === "1");
+            sendJson(res, 200, info);
+            return;
+        }
+        const editPreview = req.method === "GET" && path.match(/^\/api\/rooms\/([^/]+)\/messages\/([^/]+)\/edit-preview$/);
+        if (editPreview) {
+            const room = hub.getRoom(decodeURIComponent(editPreview[1]));
+            sendJson(res, 200, room.previewEdit(decodeURIComponent(editPreview[2])));
+            return;
+        }
+        const roomGet = req.method === "GET" && path.match(/^\/api\/rooms\/([^/]+)$/);
+        if (roomGet) {
+            sendJson(res, 200, hub.getRoom(decodeURIComponent(roomGet[1])).snapshot());
+            return;
+        }
+        if (req.method === "GET" && path === "/api/rooms") {
+            sendJson(res, 200, [...hub.rooms.values()].map((r) => r.snapshot()));
+            return;
+        }
+        if (req.method !== "POST") {
+            sendJson(res, 404, { error: "not found" });
+            return;
+        }
+        const body = (await readJson(req));
+        if (path === "/api/settings") {
+            sendJson(res, 200, { ok: true, settings: hub.updateSettings(body) });
+            return;
+        }
+        if (path === "/api/open") {
+            const target = classifyOpenTarget(String(body.target ?? ""));
+            if (!target)
+                throw new Error("only http(s) or mailto links and absolute paths can be opened");
+            let reveal = false;
+            if (target.kind === "path") {
+                try {
+                    const info = await stat(target.value);
+                    reveal = info.isFile() && isExecutablePath(target.value);
+                }
+                catch {
+                    sendJson(res, 404, { error: `no such file or folder: ${target.value}` });
+                    return;
+                }
+            }
+            const cmd = (!reveal && editorCommand(target, hub.settings.editor, currentEditor(), process.platform)) || openCommand(target, process.platform, reveal);
+            log.info(`open (${cmd.action}${cmd.editor ? ` via ${cmd.editor}` : ""}): ${target.value}${target.line !== undefined ? `:${target.line}` : ""}`);
+            const child = spawn(cmd.command, cmd.args, { detached: true, stdio: "ignore", windowsHide: true });
+            child.on("error", (error) => log.warn(`open failed: ${error.message}`));
+            child.unref();
+            sendJson(res, 200, { ok: true, action: cmd.action, editor: cmd.editor ?? null, message: describeOpen(target, cmd.action, cmd.editor) });
+            return;
+        }
+        if (path === "/api/skills") {
+            const skill = hub.saveSkill({
+                name: String(body.name ?? ""),
+                description: String(body.description ?? ""),
+                argumentHint: optionalString(body.argumentHint) ?? undefined,
+                body: String(body.body ?? ""),
+                userInvocable: body.userInvocable === undefined ? undefined : body.userInvocable === true || body.userInvocable === "true",
+                agentInvocable: body.agentInvocable === undefined ? undefined : body.agentInvocable === true || body.agentInvocable === "true",
+            });
+            sendJson(res, 200, { ok: true, skill });
+            return;
+        }
+        const skillDelete = path.match(/^\/api\/skills\/([^/]+)\/delete$/);
+        if (skillDelete) {
+            hub.removeSkill(decodeURIComponent(skillDelete[1]));
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        const skillApprove = path.match(/^\/api\/skills\/([^/]+)\/approve$/);
+        if (skillApprove) {
+            sendJson(res, 200, { ok: true, skill: hub.approveSkill(decodeURIComponent(skillApprove[1])) });
+            return;
+        }
+        if (path === "/api/mcp/skills" || path === "/api/mcp/attach") {
+            const target = hub.resolveMcpToken(String(body.token ?? ""));
+            if (!target) {
+                sendJson(res, 403, { error: "unknown skills token (the session it belonged to is gone)" });
+                return;
+            }
+            if (path === "/api/mcp/attach") {
+                const to = Array.isArray(body.to) ? body.to.map((v) => String(v)) : body.to === undefined || body.to === null || body.to === "" || body.to === "me" ? "me" : [String(body.to)];
+                sendJson(res, 200, target.room.attachSkillForAgent(target.participantId, String(body.name ?? ""), to));
+                return;
+            }
+            sendJson(res, 200, target.room.createSkillForAgent(target.participantId, {
+                op: body.op === "update" ? "update" : "create",
+                name: String(body.name ?? ""),
+                description: String(body.description ?? ""),
+                instructions: String(body.instructions ?? ""),
+                argumentHint: optionalString(body.argument_hint) ?? undefined,
+                userInvocable: body.user_invocable === undefined ? undefined : body.user_invocable === true || body.user_invocable === "true",
+                agentInvocable: body.agent_invocable === undefined ? undefined : body.agent_invocable === true || body.agent_invocable === "true",
+                dryRun: body.dry_run === true || body.dry_run === "true",
+            }));
+            return;
+        }
+        if (path === "/api/mcp/ready") {
+            const token = String(body.token ?? "");
+            const target = hub.resolveMcpToken(token);
+            if (target)
+                target.room.skillToolReady(target.participantId, token);
+            sendJson(res, 200, { ok: !!target });
+            return;
+        }
+        if (path === "/api/profile/erase") {
+            if (String(body.confirm ?? "") !== "erase")
+                throw new Error('type "erase" to confirm');
+            await hub.reset();
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        if (path === "/api/shutdown") {
+            log.info("shutdown requested over the API");
+            sendJson(res, 200, { ok: true });
+            setTimeout(onShutdownRequest, 50);
+            return;
+        }
+        if (path === "/api/rooms") {
+            const { room, notices } = hub.createRoom({
+                name: String(body.name ?? ""),
+                dir: optionalString(body.dir),
+                settings: body.settings ?? {},
+            });
+            sendJson(res, 200, { ok: true, room: room.snapshot(), notices });
+            return;
+        }
+        const roomAction = path.match(/^\/api\/rooms\/([^/]+)\/(send|typing|invite|settings|focus|rename|dir|delete)$/);
+        if (roomAction) {
+            const room = hub.getRoom(decodeURIComponent(roomAction[1]));
+            const action = roomAction[2];
+            if (action === "send") {
+                const message = room.postHumanMessage(String(body.text ?? ""));
+                sendJson(res, 200, { ok: true, id: message.id });
+            }
+            else if (action === "typing") {
+                room.humanTyping();
+                sendJson(res, 200, { ok: true });
+            }
+            else if (action === "invite") {
+                const participant = await room.inviteAgent({
+                    agentType: String(body.agentType ?? ""),
+                    name: String(body.name ?? ""),
+                    tagline: optionalString(body.tagline),
+                    role: optionalString(body.role),
+                    avatar: optionalString(body.avatar),
+                    replyDelay: body.replyDelay === undefined || body.replyDelay === null || body.replyDelay === "" ? undefined : Number(body.replyDelay),
+                    skills: stringList(body.skills),
+                    model: optionalString(body.model),
+                    effort: optionalString(body.effort),
+                    mode: optionalString(body.mode),
+                });
+                hub.saveRooms();
+                sendJson(res, 200, { ok: true, participant });
+            }
+            else if (action === "settings") {
+                const settings = room.updateSettings(body);
+                hub.saveRooms();
+                sendJson(res, 200, { ok: true, settings });
+            }
+            else if (action === "focus") {
+                room.focus();
+                sendJson(res, 200, { ok: true });
+            }
+            else if (action === "rename") {
+                room.rename(String(body.name ?? ""));
+                hub.saveRooms();
+                sendJson(res, 200, { ok: true });
+            }
+            else if (action === "dir") {
+                const result = await room.setDir(String(body.dir ?? ""));
+                const notice = hub.workspaceNotice(result.dir);
+                if (notice)
+                    room.postNotice(notice);
+                hub.saveRooms();
+                sendJson(res, 200, { ok: true, ...result });
+            }
+            else {
+                await hub.removeRoom(room.id);
+                sendJson(res, 200, { ok: true });
+            }
+            return;
+        }
+        const messageEdit = path.match(/^\/api\/rooms\/([^/]+)\/messages\/([^/]+)\/edit$/);
+        if (messageEdit) {
+            const room = hub.getRoom(decodeURIComponent(messageEdit[1]));
+            const mode = body.mode === "rewrite" ? "rewrite" : "notify";
+            const result = await room.editMessage(decodeURIComponent(messageEdit[2]), String(body.text ?? ""), mode);
+            hub.saveRooms();
+            sendJson(res, 200, { ok: true, ...result });
+            return;
+        }
+        const participantAction = path.match(/^\/api\/rooms\/([^/]+)\/participants\/([^/]+)\/(cancel|remove|config|persona|reconnect|mute|unmute)$/);
+        if (participantAction) {
+            const room = hub.getRoom(decodeURIComponent(participantAction[1]));
+            const id = decodeURIComponent(participantAction[2]);
+            const action = participantAction[3];
+            if (action === "cancel")
+                room.cancelTurn(id);
+            else if (action === "remove")
+                await room.removeParticipant(id);
+            else if (action === "reconnect") {
+                const mode = body.mode === "load" ? "load" : "replay";
+                const replay = body.replay === undefined || body.replay === null || body.replay === "" ? undefined : Number(body.replay);
+                await room.reconnect(id, { mode, replay: replay !== undefined && Number.isFinite(replay) ? Math.max(0, Math.min(500, Math.round(replay))) : undefined });
+            }
+            else if (action === "mute")
+                room.setMuted(id, true);
+            else if (action === "unmute")
+                room.setMuted(id, false);
+            else if (action === "persona") {
+                room.updatePersona(id, {
+                    name: body.name === undefined ? undefined : String(body.name),
+                    tagline: body.tagline === undefined ? undefined : String(body.tagline),
+                    role: body.role === undefined ? undefined : String(body.role),
+                    avatar: body.avatar === undefined ? undefined : String(body.avatar),
+                    replyDelay: body.replyDelay === undefined ? undefined : body.replyDelay === null || body.replyDelay === "" ? null : Number(body.replyDelay),
+                    skills: stringList(body.skills),
+                });
+            }
+            else
+                await room.setConfig(id, String(body.configId ?? ""), body.value);
+            hub.saveRooms();
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        const permission = path.match(/^\/api\/rooms\/([^/]+)\/permissions\/([^/]+)$/);
+        if (permission) {
+            const room = hub.getRoom(decodeURIComponent(permission[1]));
+            room.resolvePermission(decodeURIComponent(permission[2]), optionalString(body.optionId) ?? null);
+            sendJson(res, 200, { ok: true });
+            return;
+        }
+        sendJson(res, 404, { error: "not found" });
+    }
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, "127.0.0.1", () => {
+            const address = server.address();
+            const actualPort = typeof address === "object" && address ? address.port : port;
+            const url = `http://127.0.0.1:${actualPort}/`;
+            resolve({
+                url,
+                server,
+                close: () => {
+                    clearInterval(heartbeat);
+                    for (const res of clients)
+                        res.end();
+                    server.close();
+                },
+            });
+        });
+    });
+}
+function optionalString(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null || value === "")
+        return null;
+    return String(value);
+}
+function stringList(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value))
+        return [];
+    return value.map((v) => String(v).trim()).filter((v) => v.length > 0);
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(body));
+}
+function readJson(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            const raw = Buffer.concat(chunks).toString("utf8");
+            if (!raw.trim())
+                return resolve({});
+            try {
+                resolve(JSON.parse(raw));
+            }
+            catch {
+                reject(new Error("invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}

package/dist/shortcuts.js

@@ -0,0 +1,176 @@
+// viberoom - Copyright (c) 2026 Todor Rusev - AGPL-3.0-or-later; see LICENSE
+import { spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { findChromium } from "./launcher.js";
+export function vbsLauncher(node, main) {
+    return ["' viberoom: start the hub without a console window and open the app window.", 'Set sh = CreateObject("WScript.Shell")', `sh.Run """${node}"" ""${main}"" start", 0, False`, ""].join("\r\n");
+}
+const AUMID_BASE = { "chrome.exe": "Chrome", "msedge.exe": "MSEdge", "brave.exe": "Brave", "chromium.exe": "Chromium" };
+export function appUserModelId(browserPath, url = "http://127.0.0.1:4810/", profileDirName = "browser") {
+    if (!browserPath)
+        return null;
+    const base = AUMID_BASE[basename(browserPath).toLowerCase()];
+    if (!base)
+        return null;
+    const u = new URL(url);
+    const clean = profileDirName.replace(/[^A-Za-z0-9]/g, "");
+    const profile = clean.length > 12 ? `${clean.slice(0, 10)}${clean.slice(-2)}` : clean;
+    return `${base}.${u.hostname}_${u.pathname}.${profile}.Default`;
+}
+export const LNK_AUMID_TYPE = `using System;
+using System.Runtime.InteropServices;
+using System.Runtime.InteropServices.ComTypes;
+public static class LnkAumid {
+  [ComImport, Guid("00021401-0000-0000-C000-000000000046")] class ShellLink {}
+  [ComImport, Guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+  interface IPropertyStore { int GetCount(out uint c); int GetAt(uint i, out PROPERTYKEY k); int GetValue(ref PROPERTYKEY k, out PROPVARIANT v); int SetValue(ref PROPERTYKEY k, ref PROPVARIANT v); int Commit(); }
+  [StructLayout(LayoutKind.Sequential)] struct PROPERTYKEY { public Guid fmtid; public uint pid; }
+  [StructLayout(LayoutKind.Sequential)] struct PROPVARIANT { public ushort vt; public ushort r1; public ushort r2; public ushort r3; public IntPtr p; public int p2; }
+  [DllImport("shell32.dll")] static extern int SHGetPropertyStoreForWindow(IntPtr hwnd, ref Guid riid, out IPropertyStore ppv);
+  static PROPERTYKEY Key() { PROPERTYKEY k = new PROPERTYKEY(); k.fmtid = new Guid("9F4C2855-9F79-4B39-A8D0-E1D42DE1D5F3"); k.pid = 5; return k; }
+  static string Read(IPropertyStore store) { PROPERTYKEY key = Key(); PROPVARIANT v; store.GetValue(ref key, out v); return v.vt == 31 ? Marshal.PtrToStringUni(v.p) : ""; }
+  public static string GetWindow(IntPtr hwnd) { Guid iid = new Guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99"); IPropertyStore store; if (SHGetPropertyStoreForWindow(hwnd, ref iid, out store) != 0) return ""; return Read(store); }
+  public static string Get(string lnk) { IPersistFile link = (IPersistFile)new ShellLink(); link.Load(lnk, 0); return Read((IPropertyStore)link); }
+  public static void Set(string lnk, string aumid) {
+    IPersistFile link = (IPersistFile)new ShellLink(); link.Load(lnk, 2); // STGM_READWRITE, or Commit fails with STG_E_ACCESSDENIED
+    IPropertyStore store = (IPropertyStore)link; PROPERTYKEY key = Key();
+    PROPVARIANT v = new PROPVARIANT(); v.vt = 31; v.p = Marshal.StringToCoTaskMemUni(aumid);
+    Marshal.ThrowExceptionForHR(store.SetValue(ref key, ref v)); Marshal.ThrowExceptionForHR(store.Commit());
+    link.Save(lnk, true); Marshal.FreeCoTaskMem(v.p);
+  }
+}`;
+const psq = (s) => s.replace(/'/g, "''");
+export function shortcutScript(lnk, wscript, vbs, root, ico, aumid = null) {
+    const lines = [
+        "$ErrorActionPreference = 'Stop'",
+        `$s = (New-Object -ComObject WScript.Shell).CreateShortcut('${psq(lnk)}')`,
+        `$s.TargetPath = '${psq(wscript)}'`,
+        `$s.Arguments = '"${psq(vbs)}"'`,
+        `$s.WorkingDirectory = '${psq(root)}'`,
+        `$s.Description = 'viberoom: rooms for you and your coding agents'`,
+        ico ? `$s.IconLocation = '${psq(ico)},0'` : "",
+        "$s.Save()",
+    ].filter(Boolean);
+    if (aumid)
+        lines.push("Add-Type -TypeDefinition @'", LNK_AUMID_TYPE, "'@", `[LnkAumid]::Set('${psq(lnk)}', '${psq(aumid)}')`);
+    return lines.join("\n");
+}
+export function aumidSyncScript(profileDir, shortcuts) {
+    const list = shortcuts.map((s) => `'${psq(s)}'`).join(", ");
+    return [
+        "$ErrorActionPreference = 'SilentlyContinue'",
+        "Add-Type -TypeDefinition @'",
+        LNK_AUMID_TYPE,
+        "'@",
+        `$marker = '${psq(profileDir)}'`,
+        "$aumid = ''",
+        "for ($i = 0; $i -lt 20 -and -not $aumid; $i++) {",
+        "  Start-Sleep -Milliseconds 500",
+        "  foreach ($p in (Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like ('*' + $marker + '*') -and $_.CommandLine -like '*--app=*' })) {",
+        "    $proc = Get-Process -Id $p.ProcessId -ErrorAction SilentlyContinue",
+        "    if ($proc -and $proc.MainWindowHandle -ne 0) { $aumid = [LnkAumid]::GetWindow($proc.MainWindowHandle); if ($aumid) { break } }",
+        "  }",
+        "}",
+        `if ($aumid) { foreach ($lnk in @(${list})) { if ((Test-Path $lnk) -and ([LnkAumid]::Get($lnk) -ne $aumid)) { [LnkAumid]::Set($lnk, $aumid) } } }`,
+    ].join("\n");
+}
+export function windowsShortcutPaths(home, env, desktop) {
+    const targets = [join(env.APPDATA ?? join(home, "AppData", "Roaming"), "Microsoft", "Windows", "Start Menu", "Programs", "viberoom.lnk")];
+    if (desktop)
+        targets.push(join(home, "Desktop", "viberoom.lnk"));
+    return targets;
+}
+export function desktopEntry(node, main, icon) {
+    return ["[Desktop Entry]", "Type=Application", "Name=viberoom", "Comment=Rooms for you and your coding agents", `Exec="${node}" "${main}" start`, `Icon=${icon}`, "Terminal=false", "StartupWMClass=viberoom", "Categories=Development;Chat;", ""].join("\n");
+}
+export function macPlist(version) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>CFBundleName</key><string>viberoom</string>
+  <key>CFBundleDisplayName</key><string>viberoom</string>
+  <key>CFBundleIdentifier</key><string>dev.viberoom.launcher</string>
+  <key>CFBundleVersion</key><string>${version}</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleExecutable</key><string>viberoom</string>
+  <key>CFBundleIconFile</key><string>icon</string>
+  <key>LSMinimumSystemVersion</key><string>11.0</string>
+</dict></plist>
+`;
+}
+export function installShortcuts(o) {
+    const platform = o.platform ?? process.platform;
+    const home = o.home ?? homedir();
+    const env = o.env ?? process.env;
+    const main = join(o.root, "dist", "main.js");
+    const launcherDir = join(o.dataDir, "launcher");
+    const result = { files: [], notes: [] };
+    mkdirSync(launcherDir, { recursive: true });
+    const icoSrc = join(o.root, "assets", "icon.ico");
+    const pngSrc = join(o.root, "assets", "icon-256.png");
+    const icnsSrc = join(o.root, "assets", "icon.icns");
+    if (platform === "win32") {
+        const vbs = join(launcherDir, "viberoom.vbs");
+        writeFileSync(vbs, vbsLauncher(o.node, main));
+        result.files.push(vbs);
+        let ico = null;
+        if (existsSync(icoSrc)) {
+            ico = join(launcherDir, "viberoom.ico");
+            copyFileSync(icoSrc, ico);
+            result.files.push(ico);
+        }
+        const wscript = join(env.SystemRoot ?? "C:\\Windows", "System32", "wscript.exe");
+        const browser = o.browser === undefined ? findChromium(env, platform) : o.browser;
+        const aumid = appUserModelId(browser, "http://127.0.0.1:4810/", basename(join(o.dataDir, "browser")));
+        for (const lnk of windowsShortcutPaths(home, env, o.desktop)) {
+            mkdirSync(join(lnk, ".."), { recursive: true });
+            const r = spawnSync("powershell", ["-NoProfile", "-Command", shortcutScript(lnk, wscript, vbs, o.root, ico, aumid)], { encoding: "utf8" });
+            if (r.status === 0)
+                result.files.push(lnk);
+            else
+                result.notes.push(`could not create ${lnk}: ${(r.stderr || "").split("\n")[0]}`);
+        }
+        result.notes.push("Start Menu: viberoom" + (o.desktop ? "; Desktop: viberoom" : "") + " (double-click opens the app window)");
+        result.notes.push(aumid ? `taskbar icon: the shortcuts carry the app window's id (${aumid}); reopen the window to see it` : "taskbar icon: no Chromium found, the window will open in the default browser");
+        return result;
+    }
+    if (platform === "darwin") {
+        const app = join(home, "Applications", "viberoom.app");
+        mkdirSync(join(app, "Contents", "MacOS"), { recursive: true });
+        mkdirSync(join(app, "Contents", "Resources"), { recursive: true });
+        writeFileSync(join(app, "Contents", "Info.plist"), macPlist(o.version));
+        const exe = join(app, "Contents", "MacOS", "viberoom");
+        writeFileSync(exe, `#!/bin/sh\nexec "${o.node}" "${main}" start\n`);
+        chmodSync(exe, 0o755);
+        if (existsSync(icnsSrc))
+            copyFileSync(icnsSrc, join(app, "Contents", "Resources", "icon.icns"));
+        result.files.push(app);
+        result.notes.push(`${app}: open it from Launchpad or Finder (drag it to the Dock if you like)`);
+        return result;
+    }
+    const iconDir = join(home, ".local", "share", "icons", "hicolor", "256x256", "apps");
+    mkdirSync(iconDir, { recursive: true });
+    const icon = join(iconDir, "viberoom.png");
+    if (existsSync(pngSrc)) {
+        copyFileSync(pngSrc, icon);
+        result.files.push(icon);
+    }
+    const entry = desktopEntry(o.node, main, icon);
+    const appsDir = join(home, ".local", "share", "applications");
+    mkdirSync(appsDir, { recursive: true });
+    const menuEntry = join(appsDir, "viberoom.desktop");
+    writeFileSync(menuEntry, entry);
+    chmodSync(menuEntry, 0o755);
+    result.files.push(menuEntry);
+    if (o.desktop) {
+        mkdirSync(join(home, "Desktop"), { recursive: true });
+        const d = join(home, "Desktop", "viberoom.desktop");
+        writeFileSync(d, entry);
+        chmodSync(d, 0o755);
+        result.files.push(d);
+    }
+    result.notes.push("applications menu: viberoom" + (o.desktop ? "; Desktop: viberoom.desktop (some desktops ask once to trust it)" : ""));
+    return result;
+}