@vibevibes/mcp 0.6.0 → 0.7.0

package/dist/index.js

@@ -423,28 +423,6 @@ Call this first, then use act to interact. The stop hook keeps you present.`, {
             }
             throw stateErr;
         }
-        // Fetch slot definitions to detect unfilled autoSpawn AI slots
-        let unfilledSlots = [];
-        try {
-            const slotsData = await fetchJSON("/slots", { timeoutMs: 5000 });
-            if (slotsData?.slots) {
-                const currentParticipants = slotsData.participantDetails || [];
-                for (const slot of slotsData.slots) {
-                    if (slot.type !== "ai" && slot.type !== "any")
-                        continue;
-                    if (!slot.autoSpawn)
-                        continue;
-                    const max = slot.maxInstances ?? 1;
-                    const filled = currentParticipants.filter(p => p.role === slot.role && p.type === "ai").length;
-                    if (filled < max) {
-                        unfilledSlots.push({ role: slot.role, autoSpawn: slot.autoSpawn, maxInstances: max });
-                    }
-                }
-            }
-        }
-        catch {
-            // Slots endpoint not available — skip silently
-        }
         const outputParts = [
             `Connected as ${identity.actorId}`,
             connections.size > 1
@@ -461,10 +439,6 @@ Call this first, then use act to interact. The stop hook keeps you present.`, {
             outputParts.push(`Your instructions:`, systemPrompt, ``);
         }
         outputParts.push(formatState(state.sharedState, joinData?.observation || state.observation), `Participants: ${state.participants?.join(", ")}`, ``, `Tools:`, formatToolList(joinData?.tools || state.tools || []), ``);
-        // Surface unfilled autoSpawn slots
-        if (unfilledSlots.length > 0) {
-            outputParts.push(`UNFILLED AI SLOTS (autoSpawn):`, ...unfilledSlots.map(s => `  - ${s.role} (max ${s.maxInstances ?? 1})`), ``, `These roles need AI agents. Spawn independent teammates — each gets its own MCP session and identity.`, `  Agent(subagent_type="general-purpose", model="sonnet", run_in_background=true,`, `    prompt="Call connect with role='ROLE'. Then play your role.")`, ``);
-        }
         outputParts.push(`Use act() to interact. The stop hook keeps you present.`);
         // Register the stop hook so Claude Code wakes us on events
         ensureStopHook();

package/dist/server.js

@@ -215,13 +215,8 @@ const DEFAULT_PORT = 4321;
 const MAX_EVENTS = 200;
 const JOIN_EVENT_HISTORY = 20;
 const ROOM_STATE_EVENT_HISTORY = 50;
-const HISTORY_DEFAULT_LIMIT = 50;
-const HISTORY_MAX_LIMIT = 200;
-const DEFAULT_STREAM_RATE_LIMIT = 60;
-const STREAM_RATE_WINDOW_MS = 1000;
 const EVENT_BATCH_DEBOUNCE_MS = 50;
 const MAX_BATCH_CALLS = 10;
-const LONG_POLL_MAX_TIMEOUT_MS = 55000;
 const AGENT_CONTEXT_MAX_TIMEOUT_MS = 10000;
 const WS_MAX_PAYLOAD_BYTES = 1024 * 1024;
 const WS_EPHEMERAL_MAX_BYTES = 65536;
@@ -230,10 +225,7 @@ const HOT_RELOAD_DEBOUNCE_MS = 300;
 const WS_CLOSE_GRACE_MS = 3000;
 const JSON_BODY_LIMIT = "256kb";
 const TOOL_HTTP_TIMEOUT_MS = 30_000;
-const TOOL_REGEX_MAX_LENGTH = 100;
 const ROOM_EVENTS_MAX_LISTENERS = 200;
-const STREAM_RATE_LIMIT_STALE_MS = 5000;
-const STREAM_RATE_LIMIT_CLEANUP_INTERVAL_MS = 10000;
 const IDEMPOTENCY_CLEANUP_INTERVAL_MS = 60000;
 // ── Default observe ────────────────────────────────────────
 function defaultObserve(state, _event, _actorId) {
@@ -259,15 +251,6 @@ let experienceError = null;
 // Hot-reload rebuild gate
 let rebuildingResolve = null;
 let rebuildingPromise = null;
-// Stream rate limiting
-const streamRateLimits = new Map();
-const _streamRateCleanupTimer = setInterval(() => {
-    const now = Date.now();
-    for (const [key, entry] of streamRateLimits) {
-        if (now - entry.windowStart > STREAM_RATE_LIMIT_STALE_MS)
-            streamRateLimits.delete(key);
-    }
-}, STREAM_RATE_LIMIT_CLEANUP_INTERVAL_MS);
 export function setPublicUrl(url) {
     publicUrl = url;
 }
@@ -421,12 +404,6 @@ app.get("/state", (req, res) => {
         observation,
     });
 });
-// ── Slots endpoint ──────────────────────────────────────────
-app.get("/slots", (_req, res) => {
-    const mod = getModule();
-    const slots = mod?.manifest?.participantSlots || mod?.participants || [];
-    res.json({ slots, participantDetails: room.participantDetails() });
-});
 // ── Participants endpoint ──────────────────────────────────
 app.get("/participants", (_req, res) => res.json({ participants: room.participantDetails() }));
 // ── Tools list endpoint ────────────────────────────────────
@@ -443,79 +420,10 @@ app.get("/tools-list", (req, res) => {
         allowedTools = participant?.allowedTools;
     }
     const tools = getToolList(mod, allowedTools);
-    const streams = mod.streams
-        ? mod.streams.map((s) => ({
-            name: s.name,
-            description: s.description || "",
-            rateLimit: s.rateLimit || DEFAULT_STREAM_RATE_LIMIT,
-            input_schema: s.input_schema ? zodToJsonSchema(s.input_schema) : {},
-        }))
-        : [];
     res.json({
         experienceId: mod.manifest?.id,
         tools,
-        streams,
         toolCount: tools.length,
-        streamCount: streams.length,
-    });
-});
-// ── History endpoint ───────────────────────────────────────
-app.get("/history", (req, res) => {
-    const limit = Math.min(queryInt(req.query.limit) || HISTORY_DEFAULT_LIMIT, HISTORY_MAX_LIMIT);
-    const since = queryInt(req.query.since);
-    const actor = queryString(req.query.actor);
-    const tool = queryString(req.query.tool);
-    const owner = queryString(req.query.owner);
-    let events = room.events;
-    if (since > 0)
-        events = events.filter(e => e.ts > since);
-    if (actor)
-        events = events.filter(e => e.actorId === actor);
-    if (owner)
-        events = events.filter(e => e.owner === owner);
-    if (tool) {
-        const SAFE_TOOL_REGEX = /^[a-zA-Z0-9._:\-]+$/;
-        if (tool.length <= TOOL_REGEX_MAX_LENGTH && SAFE_TOOL_REGEX.test(tool)) {
-            try {
-                const escaped = tool.replace(/\./g, '\\.');
-                const toolRegex = new RegExp('^' + escaped + '$');
-                events = events.filter(e => toolRegex.test(e.tool));
-            }
-            catch {
-                events = events.filter(e => e.tool === tool);
-            }
-        }
-        else {
-            events = events.filter(e => e.tool === tool);
-        }
-    }
-    const filteredTotal = events.length;
-    const result = events.slice(-limit);
-    res.json({
-        events: result,
-        total: room.events.length,
-        filtered: filteredTotal,
-        returned: result.length,
-        hasMore: filteredTotal > limit,
-    });
-});
-// ── Who endpoint ───────────────────────────────────────────
-app.get("/who", (_req, res) => {
-    const participants = Array.from(room.participants.entries()).map(([actorId, p]) => {
-        let lastAction;
-        for (let i = room.events.length - 1; i >= 0; i--) {
-            if (room.events[i].actorId === actorId) {
-                lastAction = { tool: room.events[i].tool, ts: room.events[i].ts };
-                break;
-            }
-        }
-        return { actorId, owner: p.owner, type: p.type, role: p.role, joinedAt: p.joinedAt, lastAction, allowedTools: p.allowedTools };
-    });
-    res.json({
-        participants,
-        count: participants.length,
-        humans: participants.filter(p => p.type === "human").length,
-        agents: participants.filter(p => p.type === "ai").length,
     });
 });
 // ── Join ───────────────────────────────────────────────────
@@ -720,53 +628,6 @@ app.post("/leave", (req, res) => {
     broadcastPresenceUpdate();
     res.json({ left: true, actorId });
 });
-// ── Kick ───────────────────────────────────────────────────
-app.post("/kick", (req, res) => {
-    const { kickerActorId, targetActorId } = req.body;
-    if (kickerActorId === targetActorId) {
-        res.status(400).json({ error: "Cannot kick yourself" });
-        return;
-    }
-    const kicker = room.participants.get(kickerActorId);
-    if (!kicker || kicker.type !== "human") {
-        res.status(400).json({ error: "Only human participants can kick" });
-        return;
-    }
-    if (!room.participants.has(targetActorId)) {
-        res.status(400).json({ error: "Participant not found" });
-        return;
-    }
-    const targetParticipant = room.participants.get(targetActorId);
-    room.participants.delete(targetActorId);
-    if (room.kickedActors.size >= 500) {
-        const oldest = room.kickedActors.values().next().value;
-        if (oldest)
-            room.kickedActors.delete(oldest);
-    }
-    room.kickedActors.add(targetActorId);
-    if (targetParticipant?.owner) {
-        if (room.kickedOwners.size >= 500) {
-            const oldest = room.kickedOwners.values().next().value;
-            if (oldest)
-                room.kickedOwners.delete(oldest);
-        }
-        room.kickedOwners.add(targetParticipant.owner);
-    }
-    for (const [targetWs, wsActorId] of room.wsConnections.entries()) {
-        if (wsActorId === targetActorId) {
-            try {
-                targetWs.send(JSON.stringify({ type: "kicked", by: kickerActorId }));
-                targetWs.close();
-            }
-            catch { }
-            room.wsConnections.delete(targetWs);
-            break;
-        }
-    }
-    broadcastPresenceUpdate();
-    roomEvents.emit("room");
-    res.json({ kicked: true, actorId: targetActorId });
-});
 // ── Idempotency cache ────────────────────────────────────────
 const idempotencyCache = new Map();
 const IDEMPOTENCY_TTL = 30000;
@@ -1021,80 +882,6 @@ app.post("/tools-batch", async (req, res) => {
     });
     res.status(hasError ? 207 : 200).json({ results, observation: lastObservation });
 });
-// ── Events (supports long-poll via ?timeout=N) ──────────────
-app.get("/events", (req, res) => {
-    const since = queryInt(req.query.since);
-    const timeout = Math.min(queryInt(req.query.timeout), LONG_POLL_MAX_TIMEOUT_MS);
-    const requestingActorId = queryString(req.query.actorId);
-    const computeObservation = (events) => {
-        const mod = getModule();
-        if (!requestingActorId)
-            return undefined;
-        const agentObserve = mod?.observe ?? defaultObserve;
-        try {
-            const lastEvent = events.length > 0 ? events[events.length - 1] : null;
-            return agentObserve(room.sharedState, lastEvent, requestingActorId);
-        }
-        catch (e) {
-            console.error(`[observe] Error:`, toErrorMessage(e));
-            return undefined;
-        }
-    };
-    const getNewEvents = () => room.events.filter((e) => e.ts > since && e.actorId !== requestingActorId);
-    let newEvents = getNewEvents();
-    if (newEvents.length > 0 || timeout === 0) {
-        res.json({
-            events: newEvents,
-            sharedState: room.sharedState,
-            participants: room.participantList(),
-            observation: computeObservation(newEvents),
-        });
-        return;
-    }
-    let responded = false;
-    let batchTimer = null;
-    const respond = () => {
-        if (responded)
-            return;
-        responded = true;
-        clearTimeout(timer);
-        if (batchTimer) {
-            clearTimeout(batchTimer);
-            batchTimer = null;
-        }
-        roomEvents.removeListener("room", onEvent);
-        newEvents = getNewEvents();
-        res.json({
-            events: newEvents,
-            sharedState: room.sharedState,
-            participants: room.participantList(),
-            observation: computeObservation(newEvents),
-        });
-    };
-    const timer = setTimeout(respond, timeout);
-    const onEvent = () => {
-        if (responded)
-            return;
-        if (batchTimer)
-            return;
-        batchTimer = setTimeout(() => {
-            batchTimer = null;
-            if (responded)
-                return;
-            const pending = getNewEvents();
-            if (pending.length > 0)
-                respond();
-        }, EVENT_BATCH_DEBOUNCE_MS);
-    };
-    roomEvents.on("room", onEvent);
-    req.on("close", () => {
-        responded = true;
-        clearTimeout(timer);
-        if (batchTimer)
-            clearTimeout(batchTimer);
-        roomEvents.removeListener("room", onEvent);
-    });
-});
 // ── Browser error capture ──────────────────────────────────
 const browserErrors = [];
 const MAX_BROWSER_ERRORS = 20;
@@ -1239,140 +1026,10 @@ app.get("/bundle", async (_req, res) => {
     setNoCacheHeaders(res);
     res.send(loadedExperience?.clientBundle || "");
 });
-// ── Stream endpoints ───────────────────────────────────────
-app.post("/streams/:streamName", (req, res) => {
-    const mod = getModule();
-    if (!mod?.streams) {
-        res.status(404).json({ error: "No streams defined" });
-        return;
-    }
-    const streamDef = mod.streams.find((s) => s.name === req.params.streamName);
-    if (!streamDef) {
-        res.status(404).json({ error: `Stream '${req.params.streamName}' not found` });
-        return;
-    }
-    const { actorId, input } = req.body;
-    if (!actorId) {
-        res.status(400).json({ error: "actorId is required for stream updates" });
-        return;
-    }
-    if (!room.participants.has(actorId)) {
-        res.status(403).json({ error: `Actor '${actorId}' is not a participant. Call /join first.` });
-        return;
-    }
-    const rateLimitKey = `${actorId}:${req.params.streamName}`;
-    const now = Date.now();
-    const rateLimit = streamDef.rateLimit || DEFAULT_STREAM_RATE_LIMIT;
-    if (!streamRateLimits.has(rateLimitKey)) {
-        streamRateLimits.set(rateLimitKey, { count: 0, windowStart: now });
-    }
-    const rl = streamRateLimits.get(rateLimitKey);
-    if (now - rl.windowStart > STREAM_RATE_WINDOW_MS) {
-        rl.count = 0;
-        rl.windowStart = now;
-    }
-    if (rl.count >= rateLimit) {
-        res.status(429).json({ error: `Rate limited: max ${rateLimit} updates/sec for stream '${req.params.streamName}'.` });
-        return;
-    }
-    rl.count++;
-    let validatedInput = input;
-    if (streamDef.input_schema?.parse) {
-        try {
-            validatedInput = streamDef.input_schema.parse(input);
-        }
-        catch (err) {
-            res.status(400).json({ error: toErrorMessage(err) });
-            return;
-        }
-    }
-    try {
-        room.sharedState = streamDef.merge(room.sharedState, validatedInput, actorId);
-    }
-    catch (err) {
-        res.status(400).json({ error: toErrorMessage(err) });
-        return;
-    }
-    room.broadcastStateUpdate({ changedBy: actorId, stream: req.params.streamName });
-    roomEvents.emit("room");
-    res.json({ ok: true });
-});
-// ── Reset ──────────────────────────────────────────────────
-app.post("/reset", (_req, res) => {
-    const mod = getModule();
-    if (!mod) {
-        res.status(500).json({ error: experienceNotLoadedError() });
-        return;
-    }
-    room.sharedState = resolveInitialState(mod);
-    room.events.length = 0;
-    for (const [, p] of room.participants) {
-        p.eventCursor = 0;
-    }
-    const resetEvent = {
-        id: `${Date.now()}-system-${Math.random().toString(36).slice(2, 6)}`,
-        ts: Date.now(),
-        actorId: "system",
-        tool: "_reset",
-        input: {},
-        output: { reset: true },
-    };
-    room.appendEvent(resetEvent);
-    roomEvents.emit("room");
-    room.resetDeltaTracking();
-    room.broadcastStateUpdate({ changedBy: "system", tool: "_reset" }, true);
-    res.json({ ok: true });
-});
-// ── Sync (re-bundle) ──────────────────────────────────────
-app.post("/sync", async (_req, res) => {
-    try {
-        await loadExperience();
-        room.broadcastToAll({ type: "experience_updated" });
-        const mod = getModule();
-        res.json({ synced: true, title: mod?.manifest?.title });
-    }
-    catch (err) {
-        res.status(500).json({ error: toErrorMessage(err) });
-    }
-});
-// ── Experiences endpoint ───────────────────────────────────
-app.get("/experiences", async (_req, res) => {
-    const mod = getModule();
-    if (!mod) {
-        res.json([]);
-        return;
-    }
-    res.json([{
-            id: mod.manifest.id,
-            title: mod.manifest.title,
-            description: mod.manifest.description,
-            version: mod.manifest.version,
-            loaded: true,
-            category: mod.manifest.category,
-            tags: mod.manifest.tags,
-        }]);
-});
-// ── MCP config ─────────────────────────────────────────────
-app.get("/mcp-config", (_req, res) => {
-    const serverUrl = getBaseUrl();
-    res.json({
-        mcpServers: {
-            "vibevibes-remote": {
-                command: "npx",
-                args: ["-y", "@vibevibes/mcp@latest"],
-                env: { VIBEVIBES_SERVER_URL: serverUrl },
-            },
-        },
-        instructions: [
-            `Add the above to your .mcp.json to join this room.`,
-            `Or run: npx @vibevibes/mcp@latest ${serverUrl}`,
-        ],
-    });
-});
 // ── Catch-all: serve viewer ─────────────────────────────────
 app.get("*", (req, res, next) => {
     if (req.path.startsWith("/tools/") || req.path.startsWith("/viewer/") ||
-        req.path.startsWith("/streams/") || req.path.endsWith(".js") ||
+        req.path.endsWith(".js") ||
         req.path.endsWith(".css") || req.path.endsWith(".map")) {
         next();
         return;
@@ -1562,109 +1219,6 @@ export async function startServer(config) {
                         }
                     }
                 }
-                if (msg.type === "stream") {
-                    if (typeof msg.name !== "string" || !msg.name) {
-                        ws.send(JSON.stringify({ type: "stream_error", error: "stream.name must be a non-empty string" }));
-                        return;
-                    }
-                    const senderActorId = room.wsConnections.get(ws);
-                    if (!senderActorId)
-                        return;
-                    const mod = getModule();
-                    if (!mod?.streams)
-                        return;
-                    const streamDef = mod.streams.find((s) => s.name === msg.name);
-                    if (!streamDef) {
-                        ws.send(JSON.stringify({ type: "stream_error", error: `Stream '${msg.name}' not found` }));
-                        return;
-                    }
-                    const rateLimitKey = `${senderActorId}:${msg.name}`;
-                    const now = Date.now();
-                    const rateLimit = streamDef.rateLimit || DEFAULT_STREAM_RATE_LIMIT;
-                    if (!streamRateLimits.has(rateLimitKey)) {
-                        streamRateLimits.set(rateLimitKey, { count: 0, windowStart: now });
-                    }
-                    const rl = streamRateLimits.get(rateLimitKey);
-                    if (now - rl.windowStart > STREAM_RATE_WINDOW_MS) {
-                        rl.count = 0;
-                        rl.windowStart = now;
-                    }
-                    if (rl.count >= rateLimit) {
-                        ws.send(JSON.stringify({ type: "stream_error", error: `Rate limited: max ${rateLimit}/sec for '${msg.name}'` }));
-                        return;
-                    }
-                    rl.count++;
-                    let validatedInput = msg.input;
-                    if (streamDef.input_schema?.parse) {
-                        try {
-                            validatedInput = streamDef.input_schema.parse(msg.input);
-                        }
-                        catch (err) {
-                            ws.send(JSON.stringify({ type: "stream_error", error: `Invalid input for stream '${msg.name}': ${toErrorMessage(err)}` }));
-                            return;
-                        }
-                    }
-                    try {
-                        room.sharedState = streamDef.merge(room.sharedState, validatedInput, senderActorId);
-                    }
-                    catch (err) {
-                        ws.send(JSON.stringify({ type: "stream_error", error: `Stream '${msg.name}' merge failed: ${toErrorMessage(err)}` }));
-                        return;
-                    }
-                    room.broadcastStateUpdate({ changedBy: senderActorId, stream: msg.name });
-                    roomEvents.emit("room");
-                }
-                if (msg.type === "kick") {
-                    const kickerActorId = room.wsConnections.get(ws);
-                    if (!kickerActorId) {
-                        ws.send(JSON.stringify({ type: "kick_error", error: "You are not in the room" }));
-                        return;
-                    }
-                    // Reuse kick logic inline
-                    if (kickerActorId === msg.targetActorId) {
-                        ws.send(JSON.stringify({ type: "kick_error", error: "Cannot kick yourself" }));
-                        return;
-                    }
-                    const kicker = room.participants.get(kickerActorId);
-                    if (!kicker || kicker.type !== "human") {
-                        ws.send(JSON.stringify({ type: "kick_error", error: "Only human participants can kick" }));
-                        return;
-                    }
-                    if (!room.participants.has(msg.targetActorId)) {
-                        ws.send(JSON.stringify({ type: "kick_error", error: "Participant not found" }));
-                        return;
-                    }
-                    const targetP = room.participants.get(msg.targetActorId);
-                    room.participants.delete(msg.targetActorId);
-                    if (room.kickedActors.size >= 500) {
-                        const oldest = room.kickedActors.values().next().value;
-                        if (oldest)
-                            room.kickedActors.delete(oldest);
-                    }
-                    room.kickedActors.add(msg.targetActorId);
-                    if (targetP?.owner) {
-                        if (room.kickedOwners.size >= 500) {
-                            const oldest = room.kickedOwners.values().next().value;
-                            if (oldest)
-                                room.kickedOwners.delete(oldest);
-                        }
-                        room.kickedOwners.add(targetP.owner);
-                    }
-                    for (const [targetWs, wsActorId] of room.wsConnections.entries()) {
-                        if (wsActorId === msg.targetActorId) {
-                            try {
-                                targetWs.send(JSON.stringify({ type: "kicked", by: kickerActorId }));
-                                targetWs.close();
-                            }
-                            catch { }
-                            room.wsConnections.delete(targetWs);
-                            break;
-                        }
-                    }
-                    broadcastPresenceUpdate();
-                    roomEvents.emit("room");
-                    ws.send(JSON.stringify({ type: "kick_success", actorId: msg.targetActorId }));
-                }
             }
             catch (err) {
                 if (!(err instanceof SyntaxError)) {
@@ -1817,7 +1371,6 @@ export async function startServer(config) {
     server.on("close", () => {
         clearInterval(heartbeatInterval);
         clearInterval(aiHeartbeatInterval);
-        clearInterval(_streamRateCleanupTimer);
         clearInterval(_idempotencyCleanupTimer);
     });
     return server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibevibes/mcp",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "MCP server + runtime engine for vibevibes experiences",
   "type": "module",
   "main": "dist/index.js",