viberoom 0.4.1 → 0.5.0

package/dist/room.js

@@ -4,11 +4,12 @@ import { randomUUID } from "node:crypto";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { writeFileAtomic } from "./atomic.js";
 import { affectedByEdit, editNotice, partitionHistory, rewriteNotice } from "./edit.js";
+import { saveImages } from "./files.js";
 import { join, resolve } from "node:path";
 import { AcpAgent } from "./acp-client.js";
 import { RemoteError } from "./jsonrpc.js";
 import { getRecipe, listRecipes } from "./recipes.js";
-import { composeSkillBlock, SKILL_MARKER_PATTERN, SKILL_TOOL_NAME } from "./persona.js";
+import { composeSkillBlock, skillPull, SKILL_TOOL_NAME } from "./persona.js";
 import { BUILTIN_AUTHOR, parseSkillInvocation, renderSkillBody, SKILL_NAME_PATTERN, } from "./skills.js";
 import { BRIEF_AFFECTING_SETTINGS, DEFAULT_ROOM_SETTINGS, REQUEST_BRIEF_MARKER, SILENT_MARKER, buildBrief, buildHeader, composeCorrectionPrompt, composePrompt, countSentences, ensureDir, } from "./persona.js";
 import { Transcript } from "./log.js";
@@ -74,6 +75,12 @@ export class Room extends EventEmitter {
     historyPath() {
         return join(this.dataDir, "history.jsonl");
     }
+    filesDir() {
+        return join(this.dataDir, "files");
+    }
+    imagePath(attachment) {
+        return join(this.filesDir(), attachment.file);
+    }
     loadHistory() {
         if (!existsSync(this.historyPath()))
             return;
@@ -91,6 +98,10 @@ export class Room extends EventEmitter {
     }
     restore(stored) {
         for (const s of stored) {
+            if (!s.agentType) {
+                this.addUnstaffed({ name: s.name, tagline: s.tagline, role: s.role, avatar: s.avatar, skills: s.skills, color: s.color, id: s.id });
+                continue;
+            }
             const recipe = getRecipe(s.agentType);
             this.participants.set(s.id, {
                 id: s.id,
@@ -131,11 +142,11 @@ export class Room extends EventEmitter {
             createdAt: this.createdAt,
             settings,
             participants: [...this.participants.values()]
-                .filter((p) => p.kind === "agent" && p.agentType)
+                .filter((p) => p.kind === "agent" && (p.agentType || p.status === "unstaffed"))
                 .map((p) => ({
                 id: p.id,
                 name: p.name,
-                agentType: p.agentType,
+                agentType: p.agentType ?? "",
                 tagline: p.tagline ?? "",
                 role: p.role ?? "",
                 avatar: p.avatar ?? "",
@@ -236,10 +247,17 @@ export class Room extends EventEmitter {
             return gone ? `@${gone} (no longer in the room)` : "@(a participant who left)";
         });
     }
-    postHumanMessage(text) {
+    unstaffed() {
+        return [...this.participants.values()].filter((p) => p.kind === "agent" && p.status === "unstaffed");
+    }
+    postHumanMessage(text, images = []) {
+        const waiting = this.unstaffed();
+        if (waiting.length)
+            throw new Error(`${waiting.map((p) => p.name).join(", ")} ${waiting.length === 1 ? "has" : "have"} no coding agent yet: summon ${waiting.length === 1 ? "it" : "them"} from the roster to start the conversation`);
         const trimmed = text.trim();
-        if (!trimmed)
+        if (!trimmed && !images.length)
             throw new Error("empty message");
+        const attachments = images.length ? saveImages(ensureDir(this.filesDir()), images) : [];
         this.humanTypingUntil = 0;
         const human = this.participants.get("human");
         const message = {
@@ -253,6 +271,8 @@ export class Room extends EventEmitter {
             ts: Date.now(),
             kind: "chat",
         };
+        if (attachments.length)
+            message.images = attachments;
         this.decorateHumanMessage(message);
         human.turns += 1;
         if (this.focused) {
@@ -284,7 +304,7 @@ export class Room extends EventEmitter {
     agentReadStates() {
         const out = [];
         for (const p of this.participants.values()) {
-            if (p.kind !== "agent" || p.status === "left")
+            if (p.kind !== "agent" || p.status === "left" || p.status === "unstaffed")
                 continue;
             const runtime = this.runtimes.get(p.id);
             if (runtime)
@@ -300,6 +320,20 @@ export class Room extends EventEmitter {
             throw new Error("only your own chat messages can be edited");
         return message;
     }
+    setPinned(messageId, pinned) {
+        const message = this.messages.find((m) => m.id === messageId);
+        if (!message || message.kind !== "chat")
+            throw new Error("only chat messages can be pinned");
+        if (!!message.pinned === pinned)
+            return message;
+        if (pinned)
+            message.pinned = true;
+        else
+            delete message.pinned;
+        this.rewriteHistory();
+        this.push({ type: "message", message });
+        return message;
+    }
     previewEdit(messageId) {
         const message = this.editableMessage(messageId);
         const { removed } = partitionHistory(this.messages, message.seq);
@@ -334,7 +368,9 @@ export class Room extends EventEmitter {
             this.rewriteHistory();
             this.push({ type: "message", message });
             if (restart.length || offline.length)
-                this.postSystem(editNotice(this.humanName, previous, trimmed), "agents");
+                this.postSystem(editNotice(this.humanName, previous, trimmed), "agents", true);
+            for (const a of restart)
+                this.requestTurn(a.id);
             this.log.info(`edit (notify) of #${message.seq}: ${restart.length} agents had the old version`);
             this.route(message);
             return { restarted: [], removed: 0 };
@@ -380,6 +416,31 @@ export class Room extends EventEmitter {
         this.route(message);
         return { restarted, removed: removed.length };
     }
+    async respawnAgent(id) {
+        const participant = this.participants.get(id);
+        if (!participant || participant.kind !== "agent")
+            throw new Error("no such agent");
+        const online = this.runtimes.has(id);
+        this.dropScheduledTurn(id);
+        this.cancelPermissionsOf(id);
+        if (this.speaking === id)
+            this.speaking = null;
+        if (online)
+            await this.retireRuntime(id);
+        participant.sessionId = undefined;
+        this.restoredSeen.set(id, this.seq);
+        this.push({ type: "participant", participant });
+        if (!online) {
+            participant.statusDetail = "its context was cleared; a reconnect starts it with an empty head";
+            this.postSystem(`${participant.name} was respawned while offline: it comes back knowing nothing from before.`);
+            this.push({ type: "participant", participant });
+            this.log.info(`respawn of ${participant.name} (offline): stored session dropped`);
+            return participant;
+        }
+        await this.reconnect(id, { mode: "replay", replay: 0, reason: "its context was cleared, it remembers nothing from before" });
+        this.log.info(`respawn of ${participant.name}: fresh session, no replay`);
+        return participant;
+    }
     async retireRuntime(id) {
         const runtime = this.runtimes.get(id);
         const participant = this.participants.get(id);
@@ -506,6 +567,13 @@ export class Room extends EventEmitter {
                 changed.push("turnTaking");
             }
         }
+        if (patch.agentsWakeEachOther !== undefined) {
+            const on = patch.agentsWakeEachOther === true || patch.agentsWakeEachOther === "true";
+            if (on !== next.agentsWakeEachOther) {
+                next.agentsWakeEachOther = on;
+                changed.push("agentsWakeEachOther");
+            }
+        }
         if (patch.waitWhileHumanTypes !== undefined) {
             const on = patch.waitWhileHumanTypes === true || patch.waitWhileHumanTypes === "true";
             if (on !== next.waitWhileHumanTypes) {
@@ -701,9 +769,10 @@ export class Room extends EventEmitter {
         const name = options.name.trim();
         if (!NAME_PATTERN.test(name))
             throw new Error("name must be 1-24 letters, digits, _ or - (no spaces)");
-        if (this.findByName(name))
+        const taken = this.findByName(name);
+        if (taken && !(options.id && taken.id === options.id && taken.status === "unstaffed"))
             throw new Error(`name "${name}" is already taken`);
-        const id = `${recipe.id}-${name.toLowerCase()}`;
+        const id = options.id ?? `${recipe.id}-${name.toLowerCase()}`;
         const launch = {
             model: options.model ?? recipe.defaultModel,
             effort: options.effort ?? recipe.defaultEffort,
@@ -718,7 +787,7 @@ export class Room extends EventEmitter {
             agentVendor: recipe.vendor,
             status: "starting",
             turns: 0,
-            color: COLORS[this.colorIndex++ % COLORS.length],
+            color: options.color ?? COLORS[this.colorIndex++ % COLORS.length],
             tagline: (options.tagline ?? "").trim().slice(0, 80),
             role: (options.role ?? "").trim().slice(0, 4000),
             avatar: (options.avatar ?? "").trim().slice(0, 8) || undefined,
@@ -734,6 +803,51 @@ export class Room extends EventEmitter {
         await this.startAgent(participant, launch, true);
         return participant;
     }
+    addUnstaffed(input) {
+        const name = input.name.trim();
+        if (!NAME_PATTERN.test(name))
+            throw new Error("name must be 1-24 letters, digits, _ or - (no spaces)");
+        if (this.findByName(name))
+            throw new Error(`name "${name}" is already taken`);
+        const id = input.id ?? `vm-${name.toLowerCase()}`;
+        const participant = {
+            id,
+            name,
+            kind: "agent",
+            status: "unstaffed",
+            statusDetail: "awaiting a coding agent",
+            turns: 0,
+            color: input.color ?? COLORS[this.colorIndex++ % COLORS.length],
+            tagline: (input.tagline ?? "").trim().slice(0, 80),
+            role: (input.role ?? "").trim().slice(0, 4000),
+            avatar: (input.avatar ?? "").trim().slice(0, 8) || undefined,
+            skills: normalizeSkillList(input.skills),
+            violations: 0,
+            briefsSent: 0,
+            failedTurns: 0,
+        };
+        this.participants.set(id, participant);
+        this.push({ type: "participant", participant });
+        return participant;
+    }
+    async staff(id, choice) {
+        const placeholder = this.participants.get(id);
+        if (!placeholder || placeholder.kind !== "agent" || placeholder.status !== "unstaffed")
+            throw new Error("this vibemate is not awaiting a coding agent");
+        return this.inviteAgent({
+            id,
+            agentType: choice.agentType,
+            name: choice.name?.trim() || placeholder.name,
+            tagline: choice.tagline ?? placeholder.tagline,
+            role: choice.role ?? placeholder.role,
+            avatar: choice.avatar ?? placeholder.avatar,
+            skills: choice.skills ?? placeholder.skills,
+            color: placeholder.color,
+            model: choice.model,
+            effort: choice.effort,
+            mode: choice.mode,
+        });
+    }
     async reconnect(id, options = { mode: "replay" }) {
         const participant = this.participants.get(id);
         if (!participant || participant.kind !== "agent")
@@ -1019,13 +1133,18 @@ export class Room extends EventEmitter {
         else if (this.focused) {
             targets = [];
         }
-        else if (agentTargets.length) {
-            if (this.hops >= this.hopLimit) {
-                this.postSystem(`Hop limit ${this.hopLimit} reached: ${message.toNames.join(", ")} will not be prompted until ${this.humanName} writes again.`);
-            }
-            else {
-                this.hops += 1;
-                targets = agentTargets;
+        else {
+            const addressed = message.to.length > 0;
+            const wanted = agentTargets.length ? agentTargets : addressed ? [] : this.settings.agentsWakeEachOther ? [...this.runtimes.keys()].filter((id) => id !== message.from && live(id)) : [];
+            if (wanted.length) {
+                if (this.hops >= this.hopLimit) {
+                    const who = agentTargets.length ? message.toNames.join(", ") : "the other vibemates";
+                    this.postSystem(`Hop limit ${this.hopLimit} reached: ${who} will not be prompted until ${this.humanName} writes again.`);
+                }
+                else {
+                    this.hops += 1;
+                    targets = this.settings.turnTaking === "one-at-a-time" && !agentTargets.length && wanted.length > 1 ? shuffle(wanted) : wanted;
+                }
             }
         }
         this.push(this.roomEvent());
@@ -1332,10 +1451,14 @@ export class Room extends EventEmitter {
         }
         this.floorQueue.push(id);
     }
+    static TYPING_HOLD_CAP_MS = 12_000;
+    typingHoldSince = 0;
     humanIsTyping() {
-        return this.settings.waitWhileHumanTypes && Date.now() < this.humanTypingUntil;
+        return this.settings.waitWhileHumanTypes && Date.now() < this.humanTypingUntil && Date.now() - this.typingHoldSince < Room.TYPING_HOLD_CAP_MS;
     }
     humanTyping() {
+        if (Date.now() >= this.humanTypingUntil)
+            this.typingHoldSince = Date.now();
         this.humanTypingUntil = Date.now() + 4000;
         this.armTypingTimer();
     }
@@ -1417,7 +1540,7 @@ export class Room extends EventEmitter {
         if (!runtime.agent.alive || participant.muted || this.focused)
             return;
         const unreadAll = this.messages.filter((m) => m.kind !== "hidden" && m.seq > runtime.lastSeenSeq && (m.kind === "system" || m.from !== id || m.seq <= runtime.replayOwnUntilSeq));
-        if (!unreadAll.some((m) => m.kind === "chat"))
+        if (!unreadAll.some((m) => m.kind === "chat" || m.wakes))
             return;
         const cap = this.settings.backlogCap;
         const omitted = Math.max(0, unreadAll.length - cap);
@@ -1452,13 +1575,26 @@ export class Room extends EventEmitter {
             notes.push(s.invokedBy ? `${s.invokedBy} invoked your skill "${s.name}"; its instructions are attached below, follow them` : `skill "${s.name}" attached below as you asked; the same messages follow`);
         }
         const skillsForPrompt = this.skillsForPrompt(participant, runtime);
-        const promptText = composePrompt({
+        const seesImages = runtime.agent.acceptsImages;
+        const backlogImages = (m) => {
+            if (!m.images || !m.images.length)
+                return undefined;
+            const attached = seesImages && (m.to.length === 0 || m.to.includes(id));
+            return m.images.map((a, i) => ({ n: a.n ?? i + 1, ref: `#${m.seq}.${a.n ?? i + 1}`, name: a.name, path: this.imagePath(a), mimeType: a.mimeType, attached, forNames: m.to.length ? m.toNames : [] }));
+        };
+        const prompt = composePrompt({
             brief: briefReason ? buildBrief(settings, persona, roster, undefined, skillsForPrompt) : undefined,
             header: buildHeader(settings, persona, roster, this.hops, notes, skillsForPrompt),
             skills: attached.map((s) => composeSkillBlock({ name: s.name, text: s.text, invokedBy: s.invokedBy, extraFiles: s.extraFiles })),
             backlog: unread.map((m) => m.kind === "system"
                 ? { kind: "event", text: m.text }
-                : { kind: "message", fromName: m.from === id ? `${m.fromName} (you, earlier)` : m.fromName, toNames: m.toNames, text: m.text }),
+                : {
+                    kind: "message",
+                    fromName: m.from === id ? `${m.fromName} (you, earlier)` : m.fromName,
+                    toNames: m.toNames,
+                    text: m.text,
+                    images: backlogImages(m),
+                }),
             omitted,
             personaName: participant.name,
         });
@@ -1471,12 +1607,29 @@ export class Room extends EventEmitter {
         runtime.firstTurnDone = true;
         runtime.replayOwnUntilSeq = -1;
         runtime.log.info(`turn: ${unread.length} unread (${omitted} omitted), brief=${briefReason ?? "no"}, notes=${notes.length}`);
-        const retry = await this.executeTurn(participant, runtime, promptText, null);
+        const retry = await this.executeTurn(participant, runtime, this.promptBlocks(prompt, runtime), null);
         if (retry) {
-            await this.executeTurn(participant, runtime, retry.prompt, retry);
+            await this.executeTurn(participant, runtime, [{ type: "text", text: retry.prompt }], retry);
+        }
+    }
+    promptBlocks(parts, runtime) {
+        const blocks = [];
+        for (const part of parts) {
+            if (part.type === "text") {
+                blocks.push({ type: "text", text: part.text });
+                continue;
+            }
+            try {
+                blocks.push({ type: "image", data: readFileSync(part.image.path).toString("base64"), mimeType: part.image.mimeType });
+            }
+            catch (error) {
+                runtime.log.warn(`image ${part.image.ref} could not be read: ${describeError(error)}`);
+                blocks.push({ type: "text", text: ` (${part.image.ref} could not be read: ${part.image.path})` });
+            }
         }
+        return blocks;
     }
-    async executeTurn(participant, runtime, promptText, retry) {
+    async executeTurn(participant, runtime, blocks, retry) {
         const id = participant.id;
         runtime.turnActive = true;
         participant.status = "thinking";
@@ -1500,7 +1653,7 @@ export class Room extends EventEmitter {
         let result = null;
         let failure = null;
         try {
-            result = await runtime.agent.prompt(runtime.sessionId, [{ type: "text", text: promptText }]);
+            result = await runtime.agent.prompt(runtime.sessionId, blocks);
         }
         catch (error) {
             failure = error instanceof Error ? error.message : String(error);
@@ -1558,10 +1711,10 @@ export class Room extends EventEmitter {
             this.requestTurn(participant.id);
             return null;
         }
-        const pull = !retry ? text.match(SKILL_MARKER_PATTERN) : null;
+        const pull = !retry ? skillPull(text) : null;
         if (pull) {
             this.push({ type: "message.removed", id: draft.id });
-            return this.handleSkillPull(participant, runtime, text, pull[1]);
+            return this.handleSkillPull(participant, runtime, text, pull);
         }
         if (!text || text.toLowerCase() === SILENT_MARKER) {
             if (published)
@@ -1692,6 +1845,8 @@ export class Room extends EventEmitter {
         const corrections = [];
         const unknown = [];
         for (const match of text.matchAll(MENTION_PATTERN)) {
+            if (match[1].toLowerCase() === "all")
+                continue;
             if (!this.findByName(match[1]) && !unknown.includes(match[1]))
                 unknown.push(match[1]);
         }
@@ -1780,6 +1935,9 @@ export class Room extends EventEmitter {
                     view.status = u.status;
                 if (u.rawInput !== undefined)
                     view.rawInput = u.rawInput;
+                const output = toolOutputText(u);
+                if (output)
+                    view.output = output;
                 this.push({ type: "toolcall", id: turn.message.id, toolCall: view });
                 return;
             }
@@ -1994,13 +2152,23 @@ export class Room extends EventEmitter {
     }
     roster() {
         return [...this.participants.values()]
-            .filter((p) => p.status !== "left")
-            .map((p) => ({ name: p.name, kind: p.kind, vendor: p.agentVendor ?? p.agentLabel, tagline: p.tagline || undefined }));
+            .filter((p) => p.status !== "left" && p.status !== "unstaffed")
+            .map((p) => ({ name: p.name, kind: p.kind, vendor: p.agentVendor ?? p.agentLabel, tagline: p.tagline || undefined, muted: p.muted || undefined }));
     }
     parseMentions(text) {
         const ids = [];
         const names = [];
         for (const match of text.matchAll(MENTION_PATTERN)) {
+            if (match[1].toLowerCase() === "all") {
+                for (const p of this.participants.values()) {
+                    if (p.kind !== "agent" || p.status === "left" || ids.includes(p.id))
+                        continue;
+                    ids.push(p.id);
+                }
+                if (!names.includes("All"))
+                    names.push("All");
+                continue;
+            }
             const participant = this.findByName(match[1]);
             if (participant && !ids.includes(participant.id)) {
                 ids.push(participant.id);
@@ -2016,7 +2184,7 @@ export class Room extends EventEmitter {
                 return p;
         return undefined;
     }
-    postSystem(text, audience) {
+    postSystem(text, audience, wakes) {
         const message = {
             id: randomUUID(),
             seq: ++this.seq,
@@ -2030,6 +2198,8 @@ export class Room extends EventEmitter {
         };
         if (audience)
             message.audience = audience;
+        if (wakes)
+            message.wakes = true;
         this.commit(message);
     }
     async setDir(dir) {
@@ -2087,6 +2257,12 @@ export class Room extends EventEmitter {
         this.push({ type: "notice", text, level, ts: Date.now() });
     }
     push(event) {
+        if (event.type === "participant") {
+            const id = event.participant.id;
+            const lastSeenSeq = this.runtimes.get(id)?.lastSeenSeq ?? this.restoredSeen.get(id);
+            this.emit("event", { ...event, participant: { ...event.participant, lastSeenSeq } });
+            return;
+        }
         this.emit("event", event);
     }
 }
@@ -2102,6 +2278,22 @@ function looksSilent(text) {
     const t = text.trim().toLowerCase();
     return t.length <= SILENT_MARKER.length && SILENT_MARKER.startsWith(t);
 }
+function toolOutputText(u) {
+    const cap = (s) => (s.length > 4000 ? `${s.slice(0, 4000)}\n… (${s.length - 4000} more characters)` : s);
+    if (u.content && u.content.length) {
+        const parts = u.content.map((c) => {
+            if (c.type === "content")
+                return contentText(c.content);
+            if (c.type === "diff")
+                return `--- ${c.path}\n${c.oldText ? `- ${c.oldText}\n` : ""}+ ${c.newText}`;
+            return `[terminal ${c.terminalId}]`;
+        });
+        return cap(parts.join("\n"));
+    }
+    if (u.rawOutput !== undefined && u.rawOutput !== null)
+        return cap(typeof u.rawOutput === "string" ? u.rawOutput : JSON.stringify(u.rawOutput, null, 1));
+    return "";
+}
 function contentText(block) {
     if (block.type === "text")
         return block.text;

package/dist/server.js

@@ -9,6 +9,8 @@ import { existsSync as fileExists } from "node:fs";
 import { classifyOpenTarget, describeOpen, detectEditor, editorCommand, isExecutablePath, openCommand } from "./open.js";
 import { parseCsv, viewerKind, VIEWER_MAX_BYTES } from "./viewer.js";
 import { createFolder, homeFolder, listFolders, listRoots } from "./fsbrowse.js";
+import { contentTypeOf, isStoredFileName, IMAGE_MAX_BYTES, IMAGES_PER_MESSAGE } from "./files.js";
+import { commandTarget, parseRoomCommand } from "./commands.js";
 let editorFound;
 function currentEditor() {
     if (editorFound === undefined)
@@ -150,6 +152,24 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, kind === "csv" ? { ok: true, kind, path: target.value, rows: parseCsv(text) } : { ok: true, kind, path: target.value, text });
             return;
         }
+        const roomFile = req.method === "GET" && path.match(/^\/api\/rooms\/([^/]+)\/files\/([^/]+)$/);
+        if (roomFile) {
+            const room = hub.getRoom(decodeURIComponent(roomFile[1]));
+            const name = decodeURIComponent(roomFile[2]);
+            if (!isStoredFileName(name)) {
+                sendJson(res, 400, { error: "not an attachment name" });
+                return;
+            }
+            try {
+                const bytes = await readFile(join(room.filesDir(), name));
+                res.writeHead(200, { "Content-Type": contentTypeOf(name), "Cache-Control": "public, max-age=31536000, immutable" });
+                res.end(bytes);
+            }
+            catch {
+                sendJson(res, 404, { error: "no such attachment" });
+            }
+            return;
+        }
         if (req.method === "GET" && path === "/api/editor") {
             sendJson(res, 200, { editor: currentEditor(), settings: hub.settings.editor });
             return;
@@ -210,6 +230,10 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, hub.getRoom(decodeURIComponent(roomGet[1])).snapshot());
             return;
         }
+        if (req.method === "GET" && path === "/api/templates") {
+            sendJson(res, 200, { templates: hub.templates.list() });
+            return;
+        }
         if (req.method === "GET" && path === "/api/rooms") {
             sendJson(res, 200, [...hub.rooms.values()].map((r) => r.snapshot()));
             return;
@@ -322,6 +346,20 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             setTimeout(onShutdownRequest, 50);
             return;
         }
+        if (path === "/api/rooms/from-template") {
+            const vibemates = Array.isArray(body.vibemates) ? body.vibemates : [];
+            const { room, notices } = await hub.createRoomFromTemplate({
+                templateId: String(body.template ?? ""),
+                name: String(body.name ?? ""),
+                dir: optionalString(body.dir),
+                vibemates: vibemates.map((v) => {
+                    const o = (v ?? {});
+                    return { name: String(o.name ?? ""), agentType: String(o.agentType ?? ""), model: optionalString(o.model), effort: optionalString(o.effort), mode: optionalString(o.mode) };
+                }),
+            });
+            sendJson(res, 200, { ok: true, room: room.snapshot(), notices });
+            return;
+        }
         if (path === "/api/rooms") {
             const { room, notices } = hub.createRoom({
                 name: String(body.name ?? ""),
@@ -331,12 +369,27 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, { ok: true, room: room.snapshot(), notices });
             return;
         }
-        const roomAction = path.match(/^\/api\/rooms\/([^/]+)\/(send|typing|invite|settings|focus|rename|dir|delete)$/);
+        const roomAction = path.match(/^\/api\/rooms\/([^/]+)\/(send|typing|invite|settings|focus|rename|dir|delete|open)$/);
         if (roomAction) {
             const room = hub.getRoom(decodeURIComponent(roomAction[1]));
             const action = roomAction[2];
-            if (action === "send") {
-                const message = room.postHumanMessage(String(body.text ?? ""));
+            if (action === "open") {
+                hub.markOpened(room.id);
+                sendJson(res, 200, { ok: true, openRooms: hub.openRooms });
+            }
+            else if (action === "send") {
+                const text = String(body.text ?? "");
+                const command = parseRoomCommand(text);
+                if (command) {
+                    const target = room.findByName(commandTarget(command.args));
+                    if (!target)
+                        throw new Error(`/${command.name} needs the name of a vibemate in this room, like /${command.name} @Name`);
+                    await room.respawnAgent(target.id);
+                    hub.saveRooms();
+                    sendJson(res, 200, { ok: true, command: command.name, participant: target.name });
+                    return;
+                }
+                const message = room.postHumanMessage(text, imageList(body.images));
                 sendJson(res, 200, { ok: true, id: message.id });
             }
             else if (action === "typing") {
@@ -387,6 +440,13 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             }
             return;
         }
+        const messagePin = path.match(/^\/api\/rooms\/([^/]+)\/messages\/([^/]+)\/pin$/);
+        if (messagePin) {
+            const room = hub.getRoom(decodeURIComponent(messagePin[1]));
+            const message = room.setPinned(decodeURIComponent(messagePin[2]), body.pinned === true || body.pinned === "true");
+            sendJson(res, 200, { ok: true, pinned: !!message.pinned });
+            return;
+        }
         const messageEdit = path.match(/^\/api\/rooms\/([^/]+)\/messages\/([^/]+)\/edit$/);
         if (messageEdit) {
             const room = hub.getRoom(decodeURIComponent(messageEdit[1]));
@@ -396,13 +456,31 @@ export function startServer(hub, port, log, info, onShutdownRequest) {
             sendJson(res, 200, { ok: true, ...result });
             return;
         }
-        const participantAction = path.match(/^\/api\/rooms\/([^/]+)\/participants\/([^/]+)\/(cancel|remove|config|persona|reconnect|mute|unmute)$/);
+        const participantAction = path.match(/^\/api\/rooms\/([^/]+)\/participants\/([^/]+)\/(cancel|remove|config|persona|reconnect|mute|unmute|respawn|staff)$/);
         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 === "respawn")
+                await room.respawnAgent(id);
+            else if (action === "staff") {
+                const participant = await room.staff(id, {
+                    agentType: String(body.agentType ?? ""),
+                    model: optionalString(body.model),
+                    effort: optionalString(body.effort),
+                    mode: optionalString(body.mode),
+                    name: optionalString(body.name),
+                    tagline: optionalString(body.tagline),
+                    role: optionalString(body.role),
+                    avatar: optionalString(body.avatar),
+                    skills: stringList(body.skills),
+                });
+                hub.saveRooms();
+                sendJson(res, 200, { ok: true, participant });
+                return;
+            }
             else if (action === "remove")
                 await room.removeParticipant(id);
             else if (action === "reconnect") {
@@ -472,14 +550,33 @@ function stringList(value) {
         return [];
     return value.map((v) => String(v).trim()).filter((v) => v.length > 0);
 }
+function imageList(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.slice(0, IMAGES_PER_MESSAGE).map((entry) => {
+        const image = (entry ?? {});
+        const n = Number(image.n);
+        return { name: optionalString(image.name) ?? undefined, mimeType: String(image.mimeType ?? ""), data: String(image.data ?? ""), n: Number.isInteger(n) && n > 0 ? n : undefined };
+    });
+}
 function sendJson(res, status, body) {
     res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
     res.end(JSON.stringify(body));
 }
+const BODY_MAX_BYTES = (IMAGE_MAX_BYTES * IMAGES_PER_MESSAGE * 4) / 3 + 64 * 1024;
 function readJson(req) {
     return new Promise((resolve, reject) => {
         const chunks = [];
-        req.on("data", (chunk) => chunks.push(chunk));
+        let size = 0;
+        req.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > BODY_MAX_BYTES) {
+                reject(new Error("the request is too large"));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
         req.on("end", () => {
             const raw = Buffer.concat(chunks).toString("utf8");
             if (!raw.trim())

package/dist/skills.js

@@ -1,6 +1,7 @@
 // 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";
+import { isReservedSkillName, RESERVED_SKILL_NAMES } from "./commands.js";
 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";
@@ -32,6 +33,9 @@ export function lintSkill(input) {
     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 -` });
+    else if (isReservedSkillName(name)) {
+        errors.push({ code: "name-reserved", message: `"${name}" is a room command (reserved: ${RESERVED_SKILL_NAMES.join(", ")})` });
+    }
     if (input.folder && name.toLowerCase() !== input.folder.toLowerCase()) {
         errors.push({ code: "name-folder-mismatch", message: `name "${name}" differs from the folder "${input.folder}"` });
     }