vibevibes-mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,818 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { supabase, WEB_URL, SUPABASE_URL, listExperiences, getExperienceSource, getExperienceFiles, getExperienceFull, getRoomState, getRoomMetadata, getEventHistory, createRoom, countRooms, executeToolGate, webPost, joinRoom, watchRoom, leaveRoom, isJoined, getJoinedSession, getExperienceTools, getExperienceAgentHints, runExperienceTests, } from "./supabase-client.js";
+const server = new McpServer({
+    name: "vibevibes",
+    version: "0.2.0",
+});
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN || "";
+let GITHUB_OWNER = process.env.GITHUB_OWNER || "";
+async function initGitHubAuth() {
+    if (!GITHUB_TOKEN) {
+        console.error("[vibevibes-mcp] WARNING: GITHUB_TOKEN not set. Experience write operations may be limited.");
+        return;
+    }
+    try {
+        const res = await fetch("https://api.github.com/user", {
+            headers: {
+                Authorization: `Bearer ${GITHUB_TOKEN}`,
+                Accept: "application/vnd.github+json",
+            },
+        });
+        if (!res.ok) {
+            console.error(`[vibevibes-mcp] WARNING: GitHub token validation failed (HTTP ${res.status}).`);
+            return;
+        }
+        const user = (await res.json());
+        console.error(`[vibevibes-mcp] GitHub authenticated as: ${user.login}`);
+        if (!GITHUB_OWNER) {
+            GITHUB_OWNER = user.login;
+            console.error(`[vibevibes-mcp] GITHUB_OWNER derived from token: ${GITHUB_OWNER}`);
+        }
+    }
+    catch (err) {
+        console.error(`[vibevibes-mcp] WARNING: GitHub auth check failed: ${err.message}`);
+    }
+}
+server.tool("vibevibes_health", "Check health status of the vibe-vibe realtime server. Returns server status, active room count, and connection count.", {}, async () => {
+    try {
+        const roomCount = await countRooms();
+        return {
+            content: [{
+                    type: "text",
+                    text: `Server: ok (Supabase-backed)\nRooms: ${roomCount}\nConnections: N/A (serverless)`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Health check failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_diagnostics", "Get detailed diagnostics from the vibe-vibe realtime server including uptime, recent events (errors, tool calls, etc.), room count, and rate limit info. Use this to find bugs and monitor the app.", {}, async () => {
+    try {
+        const roomCount = await countRooms();
+        const { data: recentEvents } = await supabase
+            .from("room_events")
+            .select("id, room_id, ts, actor_id, tool, error")
+            .order("ts", { ascending: false })
+            .limit(20);
+        let eventLog = "No recent events.";
+        if (recentEvents && recentEvents.length > 0) {
+            eventLog = recentEvents
+                .map((e) => {
+                const time = new Date(e.ts).toISOString();
+                const level = e.error ? "ERROR" : "INFO";
+                return `[${time}] ${level} [${e.room_id}] ${e.actor_id} called ${e.tool}${e.error ? ` — ${e.error}` : ""}`;
+            })
+                .join("\n");
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Status: ok (Supabase-backed, serverless)`,
+                        `Rooms: ${roomCount}`,
+                        `Architecture: Supabase Edge Functions + Broadcast`,
+                        ``,
+                        `=== Recent Events (${recentEvents?.length || 0}) ===`,
+                        eventLog,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Diagnostics failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_list_experiences", "List all available experiences saved in Supabase. Returns id, title, description, and version for each.", {}, async () => {
+    try {
+        const exps = await listExperiences();
+        if (exps.length === 0) {
+            return { content: [{ type: "text", text: "No experiences found in Supabase." }] };
+        }
+        const list = exps
+            .map((e) => {
+            const m = e.manifest || {};
+            return `- ${e.id} | "${m.title || e.name}" | ${m.description || "(no description)"} | v${m.version || "0.0.0"}`;
+        })
+            .join("\n");
+        return { content: [{ type: "text", text: `Found ${exps.length} experience(s):\n\n${list}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to list experiences: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_get_experience_source", "Get the full source code of a specific experience. Use this to understand an experience before modifying it.", {
+    experienceId: z.string().describe("ID of the experience (e.g. 'my-app' or 'username/repo')"),
+}, async ({ experienceId }) => {
+    try {
+        const exp = await getExperienceSource(experienceId);
+        const sizeKB = ((exp.source_code?.length || 0) / 1024).toFixed(1);
+        return {
+            content: [{
+                    type: "text",
+                    text: exp.source_code + `\n\n--- Size: ${sizeKB}KB ---`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get source: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_get_experience_tools", "List all tools exported by a specific experience. Each tool has a name, description, input schema, and risk level.", {
+    experienceId: z.string().describe("ID of the experience"),
+}, async ({ experienceId }) => {
+    try {
+        const exp = await getExperienceFull(experienceId);
+        if (!exp.server_bundled_code) {
+            return { content: [{ type: "text", text: "Experience has no server bundle. Re-save to generate it." }], isError: true };
+        }
+        const tools = getExperienceTools(exp.server_bundled_code);
+        if (tools.length === 0) {
+            return { content: [{ type: "text", text: "No tools found for this experience." }] };
+        }
+        const list = tools
+            .map((t) => {
+            const schema = t.input_schema ? JSON.stringify(t.input_schema) : "{}";
+            return `- ${t.name} (risk: ${t.risk})\n  ${t.description}\n  Input: ${schema}`;
+        })
+            .join("\n\n");
+        return { content: [{ type: "text", text: `${tools.length} tool(s):\n\n${list}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get tools: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_save_experience", "Create or update an experience by saving source code. The source must be valid vibe-vibe experience code (using defineExperience, Canvas, and tools). The server will bundle and persist it automatically. When GITHUB_TOKEN is configured, the experience is committed to GitHub as the source of truth.", {
+    id: z.string().describe("Unique experience ID (e.g. 'my-app')"),
+    name: z.string().describe("Display name for the experience"),
+    sourceCode: z.string().describe("Complete TypeScript/React source code for the experience"),
+}, async ({ id, name, sourceCode }) => {
+    try {
+        const res = await webPost("/api/experiences/save", {
+            id,
+            name,
+            source_code: sourceCode,
+        });
+        const manifest = res.manifest;
+        const warnings = res.warnings || [];
+        let text = `Experience saved successfully!\n\nManifest:\n${JSON.stringify(manifest, null, 2)}`;
+        if (warnings.length > 0) {
+            text += `\n\nValidation warnings:\n${warnings.map((w) => `  - ${w}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        let errorText = `Failed to save experience: ${err.message}`;
+        if (err.data?.errors?.length) {
+            errorText += `\n\nValidation errors:\n${err.data.errors.map((e) => `  - ${e}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text: errorText }], isError: true };
+    }
+});
+server.tool("vibevibes_save_experience_files", "Create or update a multi-file experience. Accepts a map of file paths to source code content (e.g. { 'src/index.tsx': '...', 'src/components/Board.tsx': '...' }). The server bundles all files together, resolving relative imports between them, then validates and persists. Entry point must be src/index.tsx. Max total size: 2MB.", {
+    id: z.string().describe("Unique experience ID (e.g. 'my-app')"),
+    name: z.string().describe("Display name for the experience"),
+    files: z.record(z.string(), z.string()).describe("Map of file paths to source code content. Entry point: src/index.tsx. Example: { 'src/index.tsx': '...', 'src/components/Board.tsx': '...' }"),
+}, async ({ id, name, files }) => {
+    try {
+        const fileCount = Object.keys(files).length;
+        const res = await webPost("/api/experiences/save", { id, name, files });
+        const manifest = res.manifest;
+        const warnings = res.warnings || [];
+        let text = `Multi-file experience saved successfully!\n\n${fileCount} files uploaded.\n\nManifest:\n${JSON.stringify(manifest, null, 2)}`;
+        if (warnings.length > 0) {
+            text += `\n\nValidation warnings:\n${warnings.map((w) => `  - ${w}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        let errorText = `Failed to save multi-file experience: ${err.message}`;
+        if (err.data?.errors?.length) {
+            errorText += `\n\nValidation errors:\n${err.data.errors.map((e) => `  - ${e}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text: errorText }], isError: true };
+    }
+});
+server.tool("vibevibes_get_experience_files", "Get all source files for a multi-file experience. Returns a map of file paths to content. Use this to understand the full codebase of an experience before editing individual files.", {
+    experienceId: z.string().describe("ID of the experience"),
+}, async ({ experienceId }) => {
+    try {
+        const exp = await getExperienceFiles(experienceId);
+        const files = exp.source_files || {};
+        const paths = Object.keys(files);
+        if (paths.length === 0) {
+            return { content: [{ type: "text", text: "No source files found for this experience." }] };
+        }
+        const sections = paths.map((path) => {
+            const content = files[path];
+            const sizeLabel = ` (${(content.length / 1024).toFixed(1)}KB)`;
+            return `── ${path}${sizeLabel} ──\n${content}`;
+        });
+        const totalSize = paths.reduce((sum, p) => sum + files[p].length, 0);
+        const text = [
+            `Experience: ${exp.id}`,
+            `Name: ${exp.name}`,
+            `Files: ${paths.length}`,
+            `Total size: ${(totalSize / 1024).toFixed(1)}KB`,
+            ``,
+            ...sections,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get files: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_edit_experience_file", "Update or delete specific files in a multi-file experience. Provide files to create/overwrite and/or file paths to delete. The server re-bundles the full experience after applying changes, validates it, and persists. Use this for incremental edits to large experiences — no need to re-upload unchanged files.", {
+    experienceId: z.string().describe("ID of the experience to edit"),
+    files: z.record(z.string(), z.string()).optional().describe("Map of file paths to new content (creates or overwrites). Example: { 'src/components/Board.tsx': '...' }"),
+    deleteFiles: z.array(z.string()).optional().describe("List of file paths to delete. Example: ['src/old-file.ts']"),
+}, async ({ experienceId, files, deleteFiles }) => {
+    if (!files && !deleteFiles) {
+        return {
+            content: [{ type: "text", text: "Error: Must provide either 'files' (to update) or 'deleteFiles' (to remove)." }],
+            isError: true,
+        };
+    }
+    try {
+        const exp = await getExperienceFiles(experienceId);
+        const currentFiles = exp.source_files || {};
+        const updatedFiles = { ...currentFiles };
+        if (files) {
+            Object.assign(updatedFiles, files);
+        }
+        if (deleteFiles) {
+            for (const f of deleteFiles) {
+                delete updatedFiles[f];
+            }
+        }
+        const res = await webPost("/api/experiences/save", {
+            id: experienceId,
+            name: exp.name,
+            files: updatedFiles,
+        });
+        const warnings = res.warnings || [];
+        const fileCount = Object.keys(updatedFiles).length;
+        let text = `Experience '${experienceId}' updated successfully!\n\nFiles: ${fileCount}`;
+        if (files)
+            text += `\nUpdated: ${Object.keys(files).join(", ")}`;
+        if (deleteFiles?.length)
+            text += `\nDeleted: ${deleteFiles.join(", ")}`;
+        if (warnings.length > 0) {
+            text += `\n\nValidation warnings:\n${warnings.map((w) => `  - ${w}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        let errorText = `Failed to edit experience files: ${err.message}`;
+        if (err.data?.errors?.length) {
+            errorText += `\n\nValidation errors:\n${err.data.errors.map((e) => `  - ${e}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text: errorText }], isError: true };
+    }
+});
+server.tool("vibevibes_create_room", "Create a new room for a given experience. Returns the room ID and a browser URL to open the room.", {
+    experienceId: z.string().describe("ID of the experience to load in the room"),
+}, async ({ experienceId }) => {
+    try {
+        const room = await createRoom(experienceId);
+        const url = `${WEB_URL}/room/${room.id}`;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Room created!\n\nRoom ID: ${room.id}\nExperience: ${experienceId}\nOpen in browser: ${url}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to create room: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_join_room", "Join a room as a participant. The human in the browser will see you appear in the participants list. Use watch_room to long-poll for their actions. Your join stays alive as long as you keep calling watch_room (60s timeout otherwise).", {
+    roomId: z.string().describe("The room ID to join"),
+    actorId: z.string().optional().default("claude-code").describe("Your actor ID (deprecated, server assigns IDs now)"),
+    role: z.string().optional().describe("Your role in this room (e.g. 'assistant', 'moderator', 'player')"),
+    allowedTools: z.array(z.string()).optional().describe("If set, restricts this agent to only calling these tools. Other tools will be rejected."),
+}, async ({ roomId, role, allowedTools }) => {
+    try {
+        const username = GITHUB_OWNER || "claude";
+        const agentMetadata = {
+            model: "claude",
+            role: role || "assistant",
+            provider: "anthropic",
+        };
+        if (allowedTools && allowedTools.length > 0) {
+            agentMetadata.allowedTools = allowedTools;
+        }
+        const d = await joinRoom(roomId, username, role || "assistant", agentMetadata);
+        const toolsList = (d.tools || [])
+            .map((t) => `  - ${t.name} (${t.risk}): ${t.description}`)
+            .join("\n");
+        const stateStr = JSON.stringify(d.sharedState, null, 2);
+        const stateSummary = stateStr.length > 500 ? stateStr.slice(0, 500) + "\n  ..." : stateStr;
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Joined room ${roomId} as "${d.actorId}"`,
+                        ``,
+                        `Experience: ${d.experienceId || "(none)"}`,
+                        `Participants: ${(d.participants || []).join(", ")}`,
+                        `Browser URL: ${d.browserUrl}`,
+                        ``,
+                        `Available tools:`,
+                        toolsList || "  (none)",
+                        ``,
+                        `Current state:`,
+                        stateSummary,
+                        ``,
+                        `Recent events: ${(d.events || []).length}`,
+                        ``,
+                        `Use vibevibes_watch_room to long-poll for human activity.`,
+                        `Use vibevibes_execute_tool to take actions.`,
+                        `Use vibevibes_leave_room when done.`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to join room: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_watch_room", "Long-poll for new activity in a joined room. Blocks until events arrive or timeout expires. Returns events from other participants (human actions) since your last check, plus current state. Also acts as a heartbeat to keep your join alive.", {
+    roomId: z.string().describe("The room ID to watch"),
+    timeout: z.number().optional().default(30000).describe("Max time to wait in ms (default 30000, max 55000). The request blocks until events arrive or this timeout expires."),
+}, async ({ roomId, timeout }) => {
+    if (!isJoined(roomId)) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `Not joined to room ${roomId}. Call vibevibes_join_room first.`,
+                }],
+            isError: true,
+        };
+    }
+    try {
+        const clampedTimeout = Math.min(Math.max(timeout, 0), 55000);
+        const d = await watchRoom(roomId, clampedTimeout);
+        if (d.events.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `No new activity in room ${roomId} (waited ${clampedTimeout}ms).`,
+                            `Participants: ${d.participants.join(", ")}`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        const eventLines = d.events
+            .map((e) => {
+            const time = new Date(e.ts).toISOString();
+            const inputStr = JSON.stringify(e.input);
+            const result = e.error ? `ERROR: ${e.error}` : JSON.stringify(e.output);
+            return `[${time}] ${e.actorId} called ${e.tool}(${inputStr}) => ${result}`;
+        })
+            .join("\n");
+        const stateStr = JSON.stringify(d.sharedState, null, 2);
+        const stateSummary = stateStr.length > 1000 ? stateStr.slice(0, 1000) + "\n..." : stateStr;
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `${d.events.length} new event(s) in room ${roomId}:`,
+                        ``,
+                        eventLines,
+                        ``,
+                        `Current state:`,
+                        stateSummary,
+                        ``,
+                        `Participants: ${d.participants.join(", ")}`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Watch failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_leave_room", "Leave a room you previously joined. Removes you from the participants list.", {
+    roomId: z.string().describe("The room ID to leave"),
+}, async ({ roomId }) => {
+    try {
+        const actorId = await leaveRoom(roomId);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Left room ${roomId}. Removed "${actorId}" from participants.`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Leave failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_get_room_state", "Inspect the current shared state and participants of a room. Useful for debugging room state without opening a browser.", {
+    roomId: z.string().describe("The room ID to inspect"),
+}, async ({ roomId }) => {
+    try {
+        const room = await getRoomMetadata(roomId);
+        const state = await getRoomState(roomId);
+        const session = getJoinedSession(roomId);
+        const participants = session ? session.participants : [];
+        const participantNote = session ? "" : " (join room for live participant tracking)";
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Room: ${room.id}`,
+                        `Experience: ${room.experience_id || "(none)"}`,
+                        `Participants: ${participants.length}${participantNote} — ${participants.join(", ") || "(none)"}`,
+                        ``,
+                        `Shared State:`,
+                        JSON.stringify(state, null, 2),
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get room: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_room_screenshot", "Capture a screenshot of a room as it appears in the browser. Uses a headless browser to render the room and returns a PNG image. Use this to see the current visual state of an experience.", {
+    roomId: z.string().describe("The room ID to screenshot"),
+    width: z.number().optional().default(1280).describe("Viewport width in pixels"),
+    height: z.number().optional().default(800).describe("Viewport height in pixels"),
+}, async () => {
+    return {
+        content: [{
+                type: "text",
+                text: "Screenshots are not available in the serverless architecture. Use vibevibes_get_room_state to inspect room state, or open the room URL in a browser.",
+            }],
+        isError: true,
+    };
+});
+server.tool("vibevibes_execute_tool", "Execute a tool in a room. This calls the tool gate on the realtime server, which validates input, runs the handler, mutates shared state, and broadcasts updates to all connected clients.", {
+    roomId: z.string().describe("The room ID"),
+    toolName: z.string().describe("Fully-qualified tool name (e.g. 'counter.increment')"),
+    input: z.record(z.any()).describe("Tool input parameters as a JSON object"),
+    actorId: z.string().optional().default("mcp-client").describe("Actor ID for this tool call (deprecated, uses session ID from join)"),
+    owner: z.string().optional().describe("Who this action is on behalf of (e.g. a GitHub username)"),
+}, async ({ roomId, toolName, input, actorId, owner }) => {
+    try {
+        const session = getJoinedSession(roomId);
+        const resolvedActorId = session?.actorId || actorId;
+        const result = await executeToolGate(roomId, toolName, input, resolvedActorId, owner);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Tool '${toolName}' executed successfully.\n\nOutput:\n${JSON.stringify(result.output, null, 2)}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Tool call failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_edit_experience", "Create or modify an experience and assign it to a room. Supports full source code replacement or unified diff patching. This bundles, saves, invalidates cache, and hot-reloads the experience in the room.", {
+    roomId: z.string().describe("The room ID to update"),
+    sourceCode: z.string().optional().describe("Complete source code (for creating or full rewrite)"),
+    diff: z.string().optional().describe("Unified diff to apply to existing experience code (for incremental edits)"),
+    id: z.string().optional().describe("Experience ID (required when using diff mode to identify which experience to patch)"),
+    actorId: z.string().optional().default("mcp-client").describe("Actor ID (deprecated, uses session ID from join)"),
+}, async ({ roomId, sourceCode, diff, id }) => {
+    if (!sourceCode && !diff) {
+        return {
+            content: [{ type: "text", text: "Error: Must provide either 'sourceCode' or 'diff'." }],
+            isError: true,
+        };
+    }
+    try {
+        const room = await getRoomMetadata(roomId);
+        const experienceId = id || room.experience_id;
+        let finalSource = sourceCode;
+        if (diff && !sourceCode) {
+            const exp = await getExperienceSource(experienceId);
+            finalSource = applyUnifiedDiff(exp.source_code, diff);
+        }
+        if (!finalSource) {
+            return {
+                content: [{ type: "text", text: "Error: Could not determine source code." }],
+                isError: true,
+            };
+        }
+        const res = await webPost("/api/experiences/save", {
+            id: experienceId,
+            name: experienceId,
+            source_code: finalSource,
+        });
+        try {
+            const broadcastChannel = supabase.channel(`room:${roomId}`);
+            await new Promise((resolve) => {
+                broadcastChannel.subscribe((status) => {
+                    if (status === "SUBSCRIBED") {
+                        broadcastChannel.send({
+                            type: "broadcast",
+                            event: "experience_updated",
+                            payload: { experienceId },
+                        }).then(() => {
+                            supabase.removeChannel(broadcastChannel);
+                            resolve();
+                        });
+                    }
+                });
+                setTimeout(() => {
+                    supabase.removeChannel(broadcastChannel);
+                    resolve();
+                }, 3000);
+            });
+        }
+        catch {
+        }
+        const warnings = res.warnings || [];
+        let text = `Experience updated and hot-reloaded!\n\nExperience ID: ${experienceId}\nOpen in browser: ${WEB_URL}/room/${roomId}`;
+        if (warnings.length > 0) {
+            text += `\n\nValidation warnings:\n${warnings.map((w) => `  - ${w}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        let errorText = `Edit failed: ${err.message}`;
+        if (err.data?.errors?.length) {
+            errorText += `\n\nValidation errors:\n${err.data.errors.map((e) => `  - ${e}`).join("\n")}`;
+        }
+        return { content: [{ type: "text", text: errorText }], isError: true };
+    }
+});
+server.tool("vibevibes_sync_from_github", "Force re-sync an experience from its GitHub source. Use this after pushing changes directly to GitHub (outside of vibe-vibe). Re-fetches source code, re-bundles, and updates the cache.", {
+    experienceId: z.string().describe("ID of the experience to sync (e.g. 'my-app')"),
+}, async ({ experienceId }) => {
+    try {
+        await webPost("/api/experiences/sync", { experienceId });
+        return {
+            content: [{ type: "text", text: `Experience '${experienceId}' synced from GitHub successfully.` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Sync failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_run_tests", "Run the inline tests defined in an experience. Tests verify tool handlers by calling them with mock ToolCtx and checking results. Tests throw to fail; if they resolve, they pass. Returns pass/fail counts and error details.", {
+    experienceId: z.string().describe("ID of the experience to test"),
+}, async ({ experienceId }) => {
+    try {
+        const exp = await getExperienceFull(experienceId);
+        if (!exp.server_bundled_code) {
+            return {
+                content: [{ type: "text", text: `Experience '${experienceId}' has no server bundle. Re-save to generate it.` }],
+                isError: true,
+            };
+        }
+        const d = await runExperienceTests(exp.server_bundled_code);
+        if (d.total === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No tests defined for experience '${experienceId}'.\n\nTo add tests, include a \`tests\` array in your defineExperience() call using defineTest().`,
+                    }],
+            };
+        }
+        const resultLines = d.results
+            .map((r) => {
+            const icon = r.passed ? "PASS" : "FAIL";
+            const detail = r.error ? ` -- ${r.error}` : "";
+            return `  ${icon} ${r.name} (${r.durationMs}ms)${detail}`;
+        })
+            .join("\n");
+        const summary = `${d.passed}/${d.total} passed${d.failed > 0 ? ` (${d.failed} failed)` : ""} in ${d.durationMs}ms`;
+        return {
+            content: [{
+                    type: "text",
+                    text: `Test results for '${experienceId}':\n\n${resultLines}\n\n${summary}`,
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Test execution failed: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_get_event_history", "Get persisted event history for a room. Returns paginated tool call events from the database. Use this to see what happened in a room over time, even across server restarts.", {
+    roomId: z.string().describe("The room ID to get history for"),
+    limit: z.number().optional().default(50).describe("Number of events to return (max 200)"),
+    since: z.number().optional().default(0).describe("Only return events after this timestamp (epoch ms)"),
+    offset: z.number().optional().default(0).describe("Pagination offset"),
+}, async ({ roomId, limit, since, offset }) => {
+    try {
+        const d = await getEventHistory(roomId, { limit, since, offset });
+        const events = d.events;
+        if (events.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No events found for room ${roomId}${since > 0 ? ` since ${new Date(since).toISOString()}` : ""}.`,
+                    }],
+            };
+        }
+        const eventLines = events
+            .map((e) => {
+            const time = new Date(e.ts).toISOString();
+            const inputStr = JSON.stringify(e.input);
+            const result = e.error ? `ERROR: ${e.error}` : JSON.stringify(e.output);
+            return `[${time}] ${e.actor_id} called ${e.tool}(${inputStr}) => ${result}`;
+        })
+            .join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Event history for room ${roomId}: ${events.length} event(s)${d.hasMore ? " (more available)" : ""}`,
+                        ``,
+                        eventLines,
+                        ``,
+                        d.hasMore ? `Use offset=${offset + events.length} to get the next page.` : `End of history.`,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get event history: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_get_agent_hints", "Get declarative agent hints for an experience. These hints tell agents when to act, what tools to use, and under what conditions. Experience authors define these to guide agent behavior.", {
+    experienceId: z.string().describe("ID of the experience to get hints for"),
+}, async ({ experienceId }) => {
+    try {
+        const exp = await getExperienceFull(experienceId);
+        if (!exp.server_bundled_code) {
+            return {
+                content: [{ type: "text", text: `Experience '${experienceId}' has no server bundle.` }],
+                isError: true,
+            };
+        }
+        const { hints, tools } = getExperienceAgentHints(exp.server_bundled_code);
+        if (hints.length === 0) {
+            const toolsList = tools.map((t) => `  - ${t.name}: ${t.description}`).join("\n");
+            return {
+                content: [{
+                        type: "text",
+                        text: [
+                            `No agent hints defined for experience '${experienceId}'.`,
+                            ``,
+                            `Available tools:`,
+                            toolsList || "  (none)",
+                            ``,
+                            `The experience author has not specified when agents should act.`,
+                            `Use your judgment based on the available tools and room state.`,
+                        ].join("\n"),
+                    }],
+            };
+        }
+        const hintLines = hints
+            .map((h, i) => {
+            const parts = [
+                `${i + 1}. Trigger: ${h.trigger}`,
+                h.condition ? `   Condition: ${h.condition}` : null,
+                `   Suggested tools: ${h.suggestedTools.join(", ")}`,
+                h.priority ? `   Priority: ${h.priority}` : null,
+                h.cooldownMs ? `   Cooldown: ${h.cooldownMs}ms` : null,
+            ].filter(Boolean);
+            return parts.join("\n");
+        })
+            .join("\n\n");
+        const toolsList = tools.map((t) => `  - ${t.name}: ${t.description}`).join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `Agent hints for '${experienceId}' (${hints.length} hint(s)):`,
+                        ``,
+                        hintLines,
+                        ``,
+                        `Available tools:`,
+                        toolsList || "  (none)",
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to get agent hints: ${err.message}` }], isError: true };
+    }
+});
+server.tool("vibevibes_discover_agents", "Discover other AI agents in a room. Returns agent actor IDs, roles, models, and tool restrictions. Use this to coordinate with other agents.", {
+    roomId: z.string().describe("The room ID to discover agents in"),
+}, async ({ roomId }) => {
+    try {
+        const session = getJoinedSession(roomId);
+        if (!session) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Not joined to room ${roomId}. Join first to discover agents via Presence.`,
+                    }],
+                isError: true,
+            };
+        }
+        const presenceState = session.channel.presenceState();
+        const agents = [];
+        for (const [key, presences] of Object.entries(presenceState)) {
+            const presence = presences[0];
+            if (presence?.actorType === "ai") {
+                agents.push({
+                    actorId: key,
+                    model: presence.model,
+                    role: presence.role,
+                    provider: presence.provider,
+                    allowedTools: presence.allowedTools,
+                });
+            }
+        }
+        if (agents.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No AI agents currently in room ${roomId}.`,
+                    }],
+            };
+        }
+        const agentLines = agents
+            .map((a) => {
+            const parts = [
+                `- ${a.actorId}`,
+                a.model ? `  Model: ${a.model}` : null,
+                a.role ? `  Role: ${a.role}` : null,
+                a.provider ? `  Provider: ${a.provider}` : null,
+                a.allowedTools ? `  Allowed tools: ${a.allowedTools.join(", ")}` : `  Allowed tools: all`,
+            ].filter(Boolean);
+            return parts.join("\n");
+        })
+            .join("\n\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: [
+                        `${agents.length} AI agent(s) in room ${roomId}:`,
+                        ``,
+                        agentLines,
+                    ].join("\n"),
+                }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `Failed to discover agents: ${err.message}` }], isError: true };
+    }
+});
+function applyUnifiedDiff(original, diff) {
+    const lines = original.split("\n");
+    const diffLines = diff.split("\n");
+    let outputLines = [...lines];
+    let offset = 0;
+    for (let i = 0; i < diffLines.length; i++) {
+        const hunkMatch = diffLines[i].match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        if (!hunkMatch)
+            continue;
+        const origStart = parseInt(hunkMatch[1]) - 1;
+        const removals = [];
+        const additions = [];
+        let j = i + 1;
+        let lineIdx = origStart;
+        while (j < diffLines.length && !diffLines[j].startsWith("@@") && !diffLines[j].startsWith("diff ")) {
+            const line = diffLines[j];
+            if (line.startsWith("-")) {
+                removals.push(lineIdx + offset);
+                lineIdx++;
+            }
+            else if (line.startsWith("+")) {
+                additions.push(line.slice(1));
+            }
+            else if (line.startsWith(" ")) {
+                lineIdx++;
+            }
+            j++;
+        }
+        for (const idx of removals.reverse()) {
+            outputLines.splice(idx, 1);
+            offset--;
+        }
+        const insertAt = origStart + offset + removals.length;
+        outputLines.splice(insertAt, 0, ...additions);
+        offset += additions.length;
+    }
+    return outputLines.join("\n");
+}
+async function main() {
+    await initGitHubAuth();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[vibevibes-mcp] Server running on stdio (Supabase-backed)");
+    console.error(`[vibevibes-mcp] Supabase: ${SUPABASE_URL || "(NOT SET)"}`);
+    console.error(`[vibevibes-mcp] Web: ${WEB_URL}`);
+    console.error(`[vibevibes-mcp] GitHub: ${GITHUB_TOKEN ? GITHUB_OWNER : "NOT CONFIGURED (set GITHUB_TOKEN)"}`);
+}
+main().catch((error) => {
+    console.error("[vibevibes-mcp] Fatal error:", error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map