@vibevibes/mcp 0.5.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

@@ -15,8 +15,6 @@ import { ZodError } from "zod";
 import { EventEmitter } from "events";
 import { bundleForServer, bundleForClient, evalServerBundle, validateClientBundle } from "./bundler.js";
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { TickEngine } from "./tick-engine.js";
-import { isProtocolExperience, loadProtocolManifest, createProtocolModule, SubprocessExecutor } from "./protocol.js";
 function formatZodError(err, toolName, tool) {
     const issues = err.issues.map((issue) => {
         const path = issue.path.length > 0 ? `'${issue.path.join(".")}'` : "input";
@@ -217,14 +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 DEFAULT_TICK_RATE_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;
@@ -233,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) {
@@ -253,7 +242,6 @@ function defaultObserve(state, _event, _actorId) {
 let PORT = parseInt(process.env.PORT || String(DEFAULT_PORT), 10);
 let publicUrl = null;
 let room;
-let tickEngine = null;
 let _actorCounter = 0;
 const roomEvents = new EventEmitter();
 roomEvents.setMaxListeners(ROOM_EVENTS_MAX_LISTENERS);
@@ -263,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;
 }
@@ -345,9 +324,6 @@ function experienceNotLoadedError() {
 }
 // ── Experience discovery & loading ──────────────────────────
 function discoverEntryPath() {
-    const manifestPath = path.join(PROJECT_ROOT, "manifest.json");
-    if (fs.existsSync(manifestPath))
-        return manifestPath;
     const tsxPath = path.join(PROJECT_ROOT, "src", "index.tsx");
     if (fs.existsSync(tsxPath))
         return tsxPath;
@@ -355,15 +331,10 @@ function discoverEntryPath() {
     if (fs.existsSync(rootTsx))
         return rootTsx;
     throw new Error(`No experience found in ${PROJECT_ROOT}. ` +
-        `Create a manifest.json (protocol) or src/index.tsx (TypeScript).`);
+        `Create src/index.tsx (TypeScript).`);
 }
-const protocolExecutors = new Map();
 async function loadExperience() {
     const entryPath = discoverEntryPath();
-    if (isProtocolExperience(entryPath)) {
-        await loadProtocolExperience(entryPath);
-        return;
-    }
     const [sCode, cCode] = await Promise.all([
         bundleForServer(entryPath),
         bundleForClient(entryPath),
@@ -385,48 +356,6 @@ async function loadExperience() {
     };
     experienceError = null;
 }
-async function loadProtocolExperience(manifestPath) {
-    const manifestDir = path.dirname(manifestPath);
-    const manifest = loadProtocolManifest(manifestPath);
-    const existing = protocolExecutors.get(manifest.id);
-    if (existing)
-        existing.stop();
-    const executor = new SubprocessExecutor(manifest.toolProcess.command, manifest.toolProcess.args || [], manifestDir);
-    executor.start();
-    protocolExecutors.set(manifest.id, executor);
-    try {
-        await executor.send("init", { experienceId: manifest.id }, 5000);
-    }
-    catch { }
-    const mod = createProtocolModule(manifest, executor, manifestDir);
-    loadedExperience = {
-        module: mod,
-        clientBundle: "",
-        serverCode: JSON.stringify(manifest),
-        loadedAt: Date.now(),
-        sourcePath: manifestPath,
-    };
-    experienceError = null;
-    console.log(`[protocol] Loaded ${manifest.title} (${manifest.id}) — ${manifest.tools.length} tools`);
-}
-// ── Tick Engine lifecycle ──────────────────────────────────
-function maybeStartTickEngine() {
-    if (!loadedExperience)
-        return;
-    const manifest = loadedExperience.module?.manifest;
-    if (manifest?.netcode !== "tick")
-        return;
-    stopTickEngine();
-    const tickRateMs = manifest.tickRateMs || DEFAULT_TICK_RATE_MS;
-    tickEngine = new TickEngine(room, loadedExperience, roomEvents, tickRateMs);
-    tickEngine.start();
-}
-function stopTickEngine() {
-    if (tickEngine) {
-        tickEngine.stop();
-        tickEngine = null;
-    }
-}
 // ── Express app ────────────────────────────────────────────
 const app = express();
 app.use(express.json({ limit: JSON_BODY_LIMIT }));
@@ -475,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 ────────────────────────────────────
@@ -497,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 ───────────────────────────────────────────────────
@@ -774,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;
@@ -1075,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;
@@ -1186,8 +919,6 @@ app.get("/agent-context", (req, res) => {
         return room.events.filter(e => {
             if (requestingOwner && e.owner === requestingOwner)
                 return false;
-            if (e.actorId === "_tick-engine" || e.owner === "_system")
-                return false;
             return e.ts > since;
         }).sort((a, b) => a.ts - b.ts);
     };
@@ -1239,7 +970,6 @@ app.get("/agent-context", (req, res) => {
             lastError,
             browserErrors: recentBrowserErrors.length > 0 ? recentBrowserErrors : undefined,
             participants: room.participantList(),
-            tickEngine: tickEngine ? { enabled: true, tickCount: tickEngine.getStatus().tickCount } : undefined,
             eventCursor,
         };
     };
@@ -1296,165 +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 {
-        stopTickEngine();
-        await loadExperience();
-        room.broadcastToAll({ type: "experience_updated" });
-        maybeStartTickEngine();
-        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,
-        }]);
-});
-// ── Tick status ────────────────────────────────────────────
-app.get("/tick-status", (_req, res) => {
-    if (!tickEngine) {
-        res.json({ enabled: false, tickRateMs: 0, tickCount: 0, behaviorsTotal: 0, behaviorsEnabled: 0, lastTick: null });
-        return;
-    }
-    res.json(tickEngine.getStatus());
-});
-// ── 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}`,
-        ],
-    });
-});
-// ── Protocol experience HTML canvas ───────────────────────
-app.get("/canvas", async (_req, res) => {
-    if (!loadedExperience) {
-        res.status(500).json({ error: experienceNotLoadedError() });
-        return;
-    }
-    const canvasPath = loadedExperience.module?._canvasPath;
-    if (!canvasPath) {
-        res.status(404).json({ error: "This experience has no HTML canvas" });
-        return;
-    }
-    res.setHeader("Content-Type", "text/html");
-    setNoCacheHeaders(res);
-    res.sendFile(canvasPath);
-});
 // ── 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;
@@ -1497,7 +1072,6 @@ export async function startServer(config) {
     const mod = getModule();
     const initialState = resolveInitialState(mod);
     room = new Room(mod.manifest.id, initialState);
-    maybeStartTickEngine();
     console.log(`  Experience: ${mod.manifest.id}`);
     const server = http.createServer(app);
     const wss = new WebSocketServer({ server, maxPayload: WS_MAX_PAYLOAD_BYTES });
@@ -1645,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)) {
@@ -1835,11 +1306,9 @@ export async function startServer(config) {
         }
         debounceTimer = setTimeout(async () => {
             console.log(`\nFile changed${filename ? ` (${filename})` : ""}, rebuilding...`);
-            stopTickEngine();
             try {
                 await loadExperience();
                 room.broadcastToAll({ type: "experience_updated" });
-                maybeStartTickEngine();
                 smokeTestClientBundle(PORT);
                 console.log("Hot reload complete.");
             }
@@ -1847,7 +1316,6 @@ export async function startServer(config) {
                 experienceError = toErrorMessage(err);
                 console.error("Hot reload failed:", toErrorMessage(err));
                 room.broadcastToAll({ type: "build_error", error: toErrorMessage(err) });
-                maybeStartTickEngine();
             }
             finally {
                 if (rebuildingResolve) {
@@ -1903,7 +1371,6 @@ export async function startServer(config) {
     server.on("close", () => {
         clearInterval(heartbeatInterval);
         clearInterval(aiHeartbeatInterval);
-        clearInterval(_streamRateCleanupTimer);
         clearInterval(_idempotencyCleanupTimer);
     });
     return server;

package/hooks/logic.js

@@ -92,8 +92,7 @@ export function formatPrompt(ctx) {
     }
     // ── 3. Events (what happened since last wake-up) ──────
     if (ctx.events && ctx.events.length > 0) {
-        const visibleEvents = ctx.events.filter((e) => e.actorId !== "_tick-engine" &&
-            e.owner !== "_system");
+        const visibleEvents = ctx.events;
         if (visibleEvents.length > 0) {
             for (const e of visibleEvents) {
                 const actor = e.role || e.owner || (e.actorId ? e.actorId.split("-")[0] : "?");
@@ -130,9 +129,7 @@ export function formatPrompt(ctx) {
 export function makeDecision(ctx, iteration) {
     if (ctx === null)
         return null;
-    const realEvents = ctx.events?.filter((e) => e.actorId !== "_tick-engine" &&
-        e.owner !== "_system") || [];
-    const hasEvents = realEvents.length > 0;
+    const hasEvents = (ctx.events?.length || 0) > 0;
     const hasError = !!ctx.lastError;
     const hasBrowserErrors = ctx.browserErrors != null && ctx.browserErrors.length > 0;
     const hasObserveError = !!ctx.observeError;

package/package.json

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

package/dist/protocol.d.ts

@@ -1,85 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import type { ExperienceModule } from "@vibevibes/sdk";
-export interface ProtocolManifest {
-    id: string;
-    version: string;
-    title: string;
-    description?: string;
-    initialState?: Record<string, any>;
-    tools: ProtocolToolDef[];
-    toolProcess: {
-        command: string;
-        args?: string[];
-    };
-    agents?: Array<{
-        role: string;
-        systemPrompt: string;
-        allowedTools?: string[];
-        autoSpawn?: boolean;
-        maxInstances?: number;
-    }>;
-    observe?: {
-        exclude?: string[];
-        include?: string[];
-    };
-    canvas?: string;
-    netcode?: "default" | "tick";
-    tickRateMs?: number;
-    streams?: Array<{
-        name: string;
-        input_schema: Record<string, any>;
-        rateLimit?: number;
-    }>;
-}
-interface ProtocolToolDef {
-    name: string;
-    description: string;
-    input_schema: Record<string, any>;
-    risk?: "low" | "medium" | "high";
-}
-interface RpcRequest {
-    id: string;
-    method: "tool" | "observe" | "stream" | "init" | "ping";
-    params: Record<string, any>;
-}
-interface RpcResponse {
-    id: string;
-    result?: Record<string, any>;
-    error?: {
-        message: string;
-        code?: string;
-    };
-}
-export declare class SubprocessExecutor {
-    private proc;
-    private pending;
-    private buffer;
-    private seq;
-    private command;
-    private args;
-    private cwd;
-    private restarting;
-    constructor(command: string, args: string[], cwd: string);
-    start(): void;
-    stop(): void;
-    private processBuffer;
-    send(method: RpcRequest["method"], params: Record<string, any>, timeoutMs?: number): Promise<RpcResponse>;
-    get running(): boolean;
-}
-export declare function isProtocolExperience(entryPath: string): boolean;
-export declare function loadProtocolManifest(manifestPath: string): ProtocolManifest;
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export declare function createProtocolModule(manifest: ProtocolManifest, executor: SubprocessExecutor, manifestDir: string): ExperienceModule & {
-    initialState?: Record<string, any>;
-    _executor: SubprocessExecutor;
-    _canvasPath?: string;
-};
-export {};

package/dist/protocol.js

@@ -1,240 +0,0 @@
-/**
- * Protocol experience support.
- *
- * Loads experiences defined as manifest.json + subprocess tool handler.
- * The subprocess communicates via newline-delimited JSON over stdin/stdout.
- */
-import { spawn } from "child_process";
-import * as path from "path";
-import * as fs from "fs";
-// ── Subprocess executor ─────────────────────────────────────────────────
-export class SubprocessExecutor {
-    proc = null;
-    pending = new Map();
-    buffer = "";
-    seq = 0;
-    command;
-    args;
-    cwd;
-    restarting = false;
-    constructor(command, args, cwd) {
-        this.command = command;
-        this.args = args;
-        this.cwd = cwd;
-    }
-    start() {
-        if (this.proc)
-            return;
-        this.proc = spawn(this.command, this.args, {
-            cwd: this.cwd,
-            stdio: ["pipe", "pipe", "pipe"],
-            env: { ...process.env },
-        });
-        this.proc.stdout.on("data", (chunk) => {
-            this.buffer += chunk.toString();
-            this.processBuffer();
-        });
-        this.proc.stderr.on("data", (chunk) => {
-            const msg = chunk.toString().trim();
-            if (msg)
-                console.error(`[protocol:${this.command}] ${msg}`);
-        });
-        this.proc.on("exit", (code) => {
-            console.warn(`[protocol] Tool process exited with code ${code}`);
-            this.proc = null;
-            // Reject all pending requests
-            for (const [id, p] of this.pending) {
-                p.reject(new Error(`Tool process exited (code ${code})`));
-                clearTimeout(p.timer);
-            }
-            this.pending.clear();
-            this.buffer = "";
-            // Auto-restart after a short delay
-            if (!this.restarting) {
-                this.restarting = true;
-                setTimeout(() => {
-                    this.restarting = false;
-                    try {
-                        this.start();
-                    }
-                    catch { }
-                }, 1000);
-            }
-        });
-        this.proc.on("error", (err) => {
-            console.error(`[protocol] Failed to spawn tool process: ${err.message}`);
-        });
-    }
-    stop() {
-        this.restarting = true; // Prevent auto-restart
-        if (this.proc) {
-            this.proc.kill();
-            this.proc = null;
-        }
-        for (const [, p] of this.pending) {
-            p.reject(new Error("Executor stopped"));
-            clearTimeout(p.timer);
-        }
-        this.pending.clear();
-    }
-    processBuffer() {
-        const lines = this.buffer.split("\n");
-        this.buffer = lines.pop() || "";
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            try {
-                const response = JSON.parse(trimmed);
-                const pending = this.pending.get(response.id);
-                if (pending) {
-                    clearTimeout(pending.timer);
-                    this.pending.delete(response.id);
-                    pending.resolve(response);
-                }
-            }
-            catch {
-                console.warn(`[protocol] Invalid JSON from tool process: ${trimmed.slice(0, 200)}`);
-            }
-        }
-    }
-    async send(method, params, timeoutMs = 10000) {
-        if (!this.proc?.stdin?.writable) {
-            throw new Error("Tool process not running");
-        }
-        const id = `req-${++this.seq}`;
-        const request = { id, method, params };
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`Tool process timeout after ${timeoutMs}ms`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer });
-            try {
-                this.proc.stdin.write(JSON.stringify(request) + "\n");
-            }
-            catch (err) {
-                clearTimeout(timer);
-                this.pending.delete(id);
-                reject(err instanceof Error ? err : new Error(String(err)));
-            }
-        });
-    }
-    get running() {
-        return this.proc !== null && !this.proc.killed;
-    }
-}
-// ── Load a protocol experience ──────────────────────────────────────────
-export function isProtocolExperience(entryPath) {
-    return entryPath.endsWith("manifest.json");
-}
-export function loadProtocolManifest(manifestPath) {
-    const raw = fs.readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-    if (!manifest.id)
-        throw new Error("manifest.json: id is required");
-    if (!manifest.version)
-        throw new Error("manifest.json: version is required");
-    if (!manifest.title)
-        throw new Error("manifest.json: title is required");
-    if (!manifest.toolProcess)
-        throw new Error("manifest.json: toolProcess is required");
-    if (!Array.isArray(manifest.tools))
-        throw new Error("manifest.json: tools must be an array");
-    return manifest;
-}
-/**
- * Create a synthetic ExperienceModule from a protocol manifest.
- * Tool handlers proxy calls to the subprocess executor.
- */
-export function createProtocolModule(manifest, executor, manifestDir) {
-    // Create tool defs with handlers that proxy to the subprocess
-    const tools = manifest.tools.map((t) => ({
-        name: t.name,
-        description: t.description,
-        // Use a plain object as input_schema with a parse method for compatibility
-        input_schema: createJsonSchemaValidator(t.input_schema),
-        risk: (t.risk || "low"),
-        capabilities_required: ["state.write"],
-        handler: async (ctx, input) => {
-            const response = await executor.send("tool", {
-                tool: t.name,
-                input,
-                state: ctx.state,
-                actorId: ctx.actorId,
-                roomId: ctx.roomId,
-                timestamp: ctx.timestamp,
-            });
-            if (response.error) {
-                throw new Error(response.error.message);
-            }
-            if (response.result?.state) {
-                ctx.setState(response.result.state);
-            }
-            return response.result?.output ?? {};
-        },
-    }));
-    // Build observe function if manifest specifies observation config
-    let observe;
-    if (manifest.observe) {
-        const { exclude, include } = manifest.observe;
-        observe = (state, _event, _actorId) => {
-            if (include) {
-                const filtered = {};
-                for (const key of include) {
-                    if (key in state)
-                        filtered[key] = state[key];
-                }
-                return filtered;
-            }
-            if (exclude) {
-                const filtered = { ...state };
-                for (const key of exclude) {
-                    delete filtered[key];
-                }
-                return filtered;
-            }
-            return state;
-        };
-    }
-    // Resolve canvas path
-    const canvasFile = manifest.canvas || "index.html";
-    const canvasPath = path.resolve(manifestDir, canvasFile);
-    const hasCanvas = fs.existsSync(canvasPath);
-    return {
-        manifest: {
-            id: manifest.id,
-            version: manifest.version,
-            title: manifest.title,
-            description: manifest.description || "",
-            requested_capabilities: ["state.write"],
-            agentSlots: manifest.agents,
-            participantSlots: manifest.agents?.map((a) => ({ ...a, type: "ai" })),
-            netcode: manifest.netcode,
-            tickRateMs: manifest.tickRateMs,
-        },
-        Canvas: (() => null), // Protocol experiences use HTML canvas, not React
-        tools,
-        observe,
-        initialState: manifest.initialState ?? {},
-        _executor: executor,
-        _canvasPath: hasCanvas ? canvasPath : undefined,
-    };
-}
-/**
- * Create a minimal Zod-compatible validator from a JSON Schema.
- * Only needs .parse() for the server's input validation.
- */
-function createJsonSchemaValidator(schema) {
-    return {
-        parse: (input) => {
-            // Basic type validation for protocol experiences
-            if (schema.type === "object" && typeof input !== "object") {
-                throw new Error("Expected object input");
-            }
-            return input;
-        },
-        // Expose the raw JSON Schema for tool listing
-        _jsonSchema: schema,
-    };
-}

package/dist/tick-engine.d.ts

@@ -1,81 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-import type { ToolCtx, ToolEvent } from "@vibevibes/sdk";
-import type { EventEmitter } from "events";
-/** ToolEvent extended with observation field (computed server-side after tool execution). */
-interface TickToolEvent extends ToolEvent {
-    observation?: Record<string, unknown>;
-}
-/** Minimal Room interface — what the tick engine needs from a room. */
-export interface TickRoom {
-    readonly id: string;
-    readonly experienceId: string;
-    readonly config: Record<string, unknown>;
-    sharedState: Record<string, unknown>;
-    participantList(): string[];
-    broadcastToAll(message: Record<string, unknown>): void;
-    broadcastStateUpdate?(extra: {
-        changedBy: string;
-        tick?: unknown;
-    }, forceFullState?: boolean): void;
-    appendEvent(event: TickToolEvent): void;
-    enqueueExecution<T>(fn: () => Promise<T>): Promise<T>;
-}
-/** Minimal experience interface — what the tick engine needs. */
-export interface TickExperience {
-    module: {
-        manifest: {
-            id: string;
-        };
-        tools: Array<{
-            name: string;
-            input_schema?: {
-                parse?: (input: unknown) => unknown;
-            };
-            handler: (ctx: ToolCtx, input: unknown) => Promise<unknown>;
-        }>;
-        observe?: (state: Record<string, unknown>, event: TickToolEvent, actorId: string) => Record<string, unknown>;
-    };
-}
-export declare class TickEngine {
-    private room;
-    private experience;
-    private roomEvents;
-    private interval;
-    private tickCount;
-    private tickRateMs;
-    private startedAt;
-    private _running;
-    private _stopped;
-    private _stateSetThisTick;
-    constructor(room: TickRoom, experience: TickExperience, roomEvents: EventEmitter, tickRateMs?: number);
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start(): void;
-    /** Schedule the next tick with drift correction. */
-    private scheduleNext;
-    /** Stop the tick loop. */
-    stop(): void;
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty(): void;
-    /** Get current tick status. */
-    getStatus(): {
-        enabled: boolean;
-        tickRateMs: number;
-        tickCount: number;
-    };
-    /** Execute one tick cycle. */
-    private tick;
-    /** Execute a tool call internally (no HTTP round-trip). */
-    executeTool(toolName: string, input: Record<string, unknown>, callerActorId?: string, expiredFlag?: {
-        value: boolean;
-    }): Promise<{
-        output?: unknown;
-        error?: string;
-    }>;
-}
-export {};

package/dist/tick-engine.js

@@ -1,151 +0,0 @@
-/**
- * Tick Engine — server-side tick loop for experiences with netcode: "tick".
- *
- * Runs at a fixed tick rate, executing tool calls from the tick context.
- * The tick engine provides the timing infrastructure; experiences define
- * what happens each tick via their tool handlers.
- */
-// ── Tick Engine ───────────────────────────────────────────────────────────────
-const TICK_ACTOR_ID = "_tick-engine";
-const TICK_OWNER = "_system";
-export class TickEngine {
-    room;
-    experience;
-    roomEvents;
-    interval = null;
-    tickCount = 0;
-    tickRateMs;
-    startedAt = 0;
-    _running = false;
-    _stopped = false;
-    _stateSetThisTick = false;
-    constructor(room, experience, roomEvents, tickRateMs = 50) {
-        this.room = room;
-        this.experience = experience;
-        this.roomEvents = roomEvents;
-        this.tickRateMs = tickRateMs;
-    }
-    /** Start the tick loop. Uses self-correcting setTimeout to prevent timing drift. */
-    start() {
-        if (this.interval)
-            return;
-        this._stopped = false;
-        this.tickCount = 0;
-        this.startedAt = Date.now();
-        this.scheduleNext();
-    }
-    /** Schedule the next tick with drift correction. */
-    scheduleNext() {
-        if (this._stopped)
-            return;
-        const expected = this.startedAt + (this.tickCount + 1) * this.tickRateMs;
-        const delay = Math.max(0, expected - Date.now());
-        this.interval = setTimeout(() => {
-            this.tick().then(() => this.scheduleNext(), () => this.scheduleNext());
-        }, delay);
-    }
-    /** Stop the tick loop. */
-    stop() {
-        this._stopped = true;
-        this._running = false;
-        if (this.interval) {
-            clearTimeout(this.interval);
-            this.interval = null;
-        }
-    }
-    /** Mark dirty — no-op in simplified engine, kept for API compat. */
-    markDirty() { }
-    /** Get current tick status. */
-    getStatus() {
-        return {
-            enabled: this.interval !== null,
-            tickRateMs: this.tickRateMs,
-            tickCount: this.tickCount,
-        };
-    }
-    /** Execute one tick cycle. */
-    async tick() {
-        if (this._running)
-            return;
-        this._running = true;
-        try {
-            this.tickCount++;
-        }
-        finally {
-            this._running = false;
-        }
-    }
-    /** Execute a tool call internally (no HTTP round-trip). */
-    async executeTool(toolName, input, callerActorId, expiredFlag) {
-        const tool = this.experience.module.tools.find((t) => t.name === toolName);
-        if (!tool) {
-            return { error: `Tool '${toolName}' not found` };
-        }
-        const actorId = callerActorId || TICK_ACTOR_ID;
-        const owner = callerActorId || TICK_OWNER;
-        try {
-            let validatedInput = input;
-            if (tool.input_schema?.parse) {
-                validatedInput = tool.input_schema.parse(input);
-            }
-            const self = this;
-            const ctxBase = {
-                roomId: this.room.id,
-                actorId,
-                owner,
-                state: null,
-                setState: (newState) => {
-                    if (expiredFlag?.value)
-                        return;
-                    self.room.sharedState = newState;
-                    self._stateSetThisTick = true;
-                },
-                timestamp: Date.now(),
-                memory: {},
-                setMemory: () => { },
-            };
-            Object.defineProperty(ctxBase, 'state', {
-                get() { return self.room.sharedState; },
-                enumerable: true,
-                configurable: true,
-            });
-            const ctx = ctxBase;
-            const output = await tool.handler(ctx, validatedInput);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input: validatedInput,
-                output,
-            };
-            if (this.experience.module.observe) {
-                try {
-                    event.observation = this.experience.module.observe(this.room.sharedState, event, actorId);
-                }
-                catch {
-                    // Don't fail tick if observe throws
-                }
-            }
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { output };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            const event = {
-                id: `tick-${this.tickCount}-${toolName}-${Math.random().toString(36).slice(2, 6)}`,
-                ts: Date.now(),
-                actorId: TICK_ACTOR_ID,
-                owner: TICK_OWNER,
-                tool: toolName,
-                input,
-                error: errorMsg,
-            };
-            this.room.appendEvent(event);
-            this.roomEvents.emit(`room:${this.room.id}`);
-            return { error: errorMsg };
-        }
-    }
-}