threlte-mcp 1.4.0

package/dist/index.js

@@ -0,0 +1,808 @@
+#!/usr/bin/env node
+/**
+ * Threlte MCP Server
+ *
+ * An MCP server that exposes Three.js/Threlte scenes to AI agents
+ * for inspection, debugging, and manipulation.
+ *
+ * Usage:
+ *   npx threlte-mcp
+ *
+ * Prerequisites:
+ *   1. Game must be running with MCPBridge component
+ *   2. MCPBridge connects to ws://localhost:8082
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { BridgeServer } from './bridge-server.js';
+import { analyzeGltf, optimizeGltf, validateGltf } from './gltf-tools.js';
+import { cameraPresets } from './camera-presets.js';
+import { exportToSvelte } from './svelte-generator.js';
+// Tool definitions
+const TOOLS = [
+    // Scene Inspection
+    {
+        name: 'get_scene_state',
+        description: 'Get the full scene hierarchy with all named objects, positions, and transforms',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                maxDepth: { type: 'number', description: 'Maximum depth to traverse (default: 3)' }
+            }
+        }
+    },
+    {
+        name: 'find_objects',
+        description: 'Search for objects by name, type, or userData properties',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Exact object name to find' },
+                nameContains: { type: 'string', description: 'Partial name match' },
+                type: { type: 'string', description: 'Object type (Mesh, Group, etc.)' },
+                hasUserData: { type: 'string', description: 'UserData property key that must exist' }
+            }
+        }
+    },
+    {
+        name: 'get_object_position',
+        description: 'Get the position of a specific object by name',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'log_positions',
+        description: 'Log all object positions in copy-paste format for code',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filter: { type: 'string', description: 'Optional name filter' }
+            }
+        }
+    },
+    // Camera Control
+    {
+        name: 'set_camera_position',
+        description: 'Set camera position with optional lookAt target and lens settings',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Optional camera object name' },
+                position: { type: 'array', items: { type: 'number' }, description: '[x, y, z] position' },
+                lookAt: { type: 'array', items: { type: 'number' }, description: '[x, y, z] look target' },
+                fov: { type: 'number', description: 'Field of view in degrees (PerspectiveCamera)' },
+                near: { type: 'number', description: 'Near clipping plane' },
+                far: { type: 'number', description: 'Far clipping plane' }
+            },
+            required: ['position']
+        }
+    },
+    {
+        name: 'save_camera_preset',
+        description: 'Save current camera position as a named preset for quick recall',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Preset name (e.g., "overhead", "closeup")' },
+                description: { type: 'string', description: 'Optional description of this view' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'load_camera_preset',
+        description: 'Load a saved camera preset and optionally animate to it',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Preset name to load' },
+                animate: { type: 'boolean', description: 'Smoothly animate to position (default: false)' },
+                duration: { type: 'number', description: 'Animation duration in ms (default: 1000)' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'list_camera_presets',
+        description: 'List all available camera presets',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'delete_camera_preset',
+        description: 'Delete a saved camera preset',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Preset name to delete' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'animate_camera_presets',
+        description: 'Animate the camera through a sequence of saved presets',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                presets: { type: 'array', items: { type: 'string' }, description: 'Ordered list of preset names' },
+                duration: { type: 'number', description: 'Transition duration per preset in ms (default: 1000)' },
+                hold: { type: 'number', description: 'Hold time per preset in ms (default: 0)' },
+                repeat: { type: 'number', description: 'Number of times to repeat the sequence (default: 1)' }
+            },
+            required: ['presets']
+        }
+    },
+    // Hierarchy Management
+    {
+        name: 'spawn_entity',
+        description: 'Spawn a new primitive entity (box, sphere, plane, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                type: { type: 'string', description: 'Primitive type: box, sphere, plane, cylinder, cone, torus' },
+                name: { type: 'string', description: 'Name for the new entity' },
+                position: { type: 'array', items: { type: 'number' }, description: '[x, y, z] position' },
+                color: { type: 'string', description: 'Hex color (e.g., #ff0000)' },
+                parentName: { type: 'string', description: 'Optional parent object name' }
+            },
+            required: ['type', 'name']
+        }
+    },
+    {
+        name: 'destroy_entity',
+        description: 'Remove an entity from the scene',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Entity name to destroy' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'move_object',
+        description: 'Move an object to a new position',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name or path' },
+                position: { type: 'array', items: { type: 'number' }, description: '[x, y, z] position' }
+            },
+            required: ['name', 'position']
+        }
+    },
+    {
+        name: 'set_transform',
+        description: 'Set position, rotation, and/or scale of an object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' },
+                position: { type: 'array', items: { type: 'number' }, description: '[x, y, z]' },
+                rotation: { type: 'array', items: { type: 'number' }, description: '[x, y, z] in radians' },
+                scale: { type: 'array', items: { type: 'number' }, description: '[x, y, z]' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'set_visibility',
+        description: 'Show or hide an object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' },
+                visible: { type: 'boolean', description: 'Visibility state' }
+            },
+            required: ['name', 'visible']
+        }
+    },
+    {
+        name: 'rename_entity',
+        description: 'Rename an object in the scene',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                oldName: { type: 'string', description: 'Current name' },
+                newName: { type: 'string', description: 'New name' }
+            },
+            required: ['oldName', 'newName']
+        }
+    },
+    {
+        name: 'duplicate_entity',
+        description: 'Clone an object with optional position offset',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object to clone' },
+                newName: { type: 'string', description: 'Name for the clone' },
+                offset: { type: 'array', items: { type: 'number' }, description: '[x, y, z] offset from original' }
+            },
+            required: ['name', 'newName']
+        }
+    },
+    // Physics
+    {
+        name: 'make_physical',
+        description: 'Add physics body to an object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' },
+                type: { type: 'string', description: 'Body type: dynamic, kinematic, static' },
+                colliders: { type: 'string', description: 'Collider type: cuboid, ball, hull, trimesh, auto' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'remove_physics',
+        description: 'Remove physics body from an object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'apply_impulse',
+        description: 'Apply an impulse force to a physics object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' },
+                vector: { type: 'array', items: { type: 'number' }, description: '[x, y, z] impulse' }
+            },
+            required: ['name', 'vector']
+        }
+    },
+    {
+        name: 'set_gravity',
+        description: 'Set global gravity vector',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                vector: { type: 'array', items: { type: 'number' }, description: '[x, y, z] gravity' }
+            },
+            required: ['vector']
+        }
+    },
+    // Materials & Assets
+    {
+        name: 'analyze_gltf',
+        description: 'Analyze a GLTF/GLB file for meshes, materials, textures, and animations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Local path or file:// URL to a .gltf/.glb file' }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'validate_asset',
+        description: 'Validate a GLTF/GLB file for structural and performance issues',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Local path or file:// URL to a .gltf/.glb file' },
+                limits: {
+                    type: 'object',
+                    properties: {
+                        maxDrawCalls: { type: 'number', description: 'Max draw calls before warning' },
+                        maxTriangles: { type: 'number', description: 'Max triangles before warning' },
+                        maxVertices: { type: 'number', description: 'Max vertices before warning' },
+                        maxTextures: { type: 'number', description: 'Max textures before warning' },
+                        maxMaterials: { type: 'number', description: 'Max materials before warning' },
+                        maxAnimations: { type: 'number', description: 'Max animations before warning' }
+                    }
+                }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'optimize_gltf',
+        description: 'Optimize a GLTF/GLB file with mesh simplification and texture compression',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Local path or file:// URL to a .gltf/.glb file' },
+                output: { type: 'string', description: 'Output path for optimized file' },
+                options: {
+                    type: 'object',
+                    properties: {
+                        dedup: { type: 'boolean', description: 'Remove duplicate accessors/materials (default: true)' },
+                        prune: { type: 'boolean', description: 'Remove unused data (default: true)' },
+                        weld: { type: 'boolean', description: 'Weld shared vertices (default: true)' },
+                        quantize: { type: 'boolean', description: 'Quantize vertex data (default: true)' },
+                        simplify: {
+                            type: 'object',
+                            properties: {
+                                ratio: { type: 'number', description: 'Target ratio (0-1) of vertices to keep' },
+                                error: { type: 'number', description: 'Maximum simplification error' },
+                                lockBorder: { type: 'boolean', description: 'Preserve mesh borders' }
+                            }
+                        },
+                        textures: {
+                            type: 'object',
+                            properties: {
+                                format: { type: 'string', description: 'Target texture format: jpeg, png, webp, avif' },
+                                resize: {
+                                    description: 'Resize textures [width,height] or power-of-two preset',
+                                    type: ['array', 'string'],
+                                    items: { type: 'number' }
+                                },
+                                quality: { type: 'number', description: 'Compression quality (1-100)' },
+                                useSharp: { type: 'boolean', description: 'Use sharp encoder when available' }
+                            }
+                        }
+                    }
+                }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'export_to_svelte',
+        description: 'Generate a Threlte/Svelte component from a GLTF/GLB file',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Local path or file:// URL to a .gltf/.glb file' },
+                output: { type: 'string', description: 'Output .svelte file path (optional)' },
+                componentName: { type: 'string', description: 'Component name override' },
+                assetUrl: { type: 'string', description: 'Asset URL to load in the generated component' },
+                mode: { type: 'string', description: 'Export mode: nodes or primitive' }
+            },
+            required: ['path']
+        }
+    },
+    {
+        name: 'load_asset',
+        description: 'Load a GLTF/GLB model into the scene',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL or path to the asset' },
+                name: { type: 'string', description: 'Name for the loaded model' },
+                position: { type: 'array', items: { type: 'number' }, description: '[x, y, z]' },
+                scale: { type: 'array', items: { type: 'number' }, description: '[x, y, z]' }
+            },
+            required: ['url', 'name']
+        }
+    },
+    {
+        name: 'apply_material',
+        description: 'Apply a material to an object',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Object name' },
+                type: { type: 'string', description: 'Material type: Standard, Physical, Basic, Toon' },
+                color: { type: 'string', description: 'Hex color' },
+                preset: { type: 'string', description: 'Material preset: cyberpunk, gold, glass, cartoon' }
+            },
+            required: ['name']
+        }
+    },
+    {
+        name: 'set_environment',
+        description: 'Set the scene environment/skybox',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                preset: { type: 'string', description: 'Environment preset: sunset, dawn, night, warehouse, forest, apartment, studio, city, park, lobby' },
+                blur: { type: 'number', description: 'Background blur amount' },
+                background: { type: 'boolean', description: 'Show environment as background' }
+            },
+            required: ['preset']
+        }
+    },
+    // Vibe & Atmosphere
+    {
+        name: 'apply_vibe',
+        description: 'Apply a visual vibe/mood preset to the scene',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                vibe: { type: 'string', description: 'Vibe name: cozy, spooky, neon, retro, minimal, chaos' }
+            },
+            required: ['vibe']
+        }
+    },
+    // Bridge Status
+    {
+        name: 'get_bridge_status',
+        description: 'Get the connection status of the bridge server',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    }
+];
+const LOCAL_ONLY_TOOLS = new Set([
+    'get_bridge_status',
+    'analyze_gltf',
+    'validate_asset',
+    'optimize_gltf',
+    'export_to_svelte',
+    'list_camera_presets',
+    'delete_camera_preset',
+]);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Create MCP server
+const server = new Server({
+    name: 'threlte-mcp',
+    version: '1.4.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Bridge server for WebSocket communication
+const bridge = new BridgeServer();
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (!bridge.isConnected() && !LOCAL_ONLY_TOOLS.has(name)) {
+        try {
+            await bridge.connect();
+        }
+        catch {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to connect to game. Make sure:\n1. Game is running (npm run dev)\n2. MCPBridge is added to your scene (auto-connects in dev mode)\n3. For production: Set VITE_MCP_ENABLED=true in .env file`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    try {
+        switch (name) {
+            case 'get_scene_state': {
+                const maxDepth = args?.maxDepth ?? 3;
+                const result = await bridge.sendCommand({ action: 'getFullSceneState', maxDepth });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'find_objects': {
+                const { name: objName, nameContains, type, hasUserData } = args;
+                const result = await bridge.sendCommand({
+                    action: 'findObjects',
+                    name: objName,
+                    filter: { nameContains, type, hasUserData },
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'get_object_position': {
+                const { name: objName } = args;
+                const result = await bridge.sendCommand({ action: 'findObjects', name: objName });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'set_camera_position': {
+                const { name: cameraName, position, lookAt, fov, near, far } = args;
+                await bridge.sendCommand({
+                    action: 'setCameraPosition',
+                    name: cameraName,
+                    position,
+                    lookAt,
+                    fov,
+                    near,
+                    far,
+                });
+                const target = cameraName ? `camera "${cameraName}"` : 'camera';
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `OK. Set ${target} position to [${position.join(', ')}]`
+                        }]
+                };
+            }
+            case 'save_camera_preset': {
+                const { name: presetName, description } = args;
+                // Get current camera position from scene
+                const currentCamera = await bridge.sendCommand({ action: 'getCameraState' });
+                const preset = {
+                    name: presetName,
+                    position: currentCamera.position,
+                    lookAt: currentCamera.lookAt,
+                    fov: currentCamera.fov,
+                    near: currentCamera.near,
+                    far: currentCamera.far,
+                    description
+                };
+                cameraPresets.savePreset(preset);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `OK. Saved camera preset "${presetName}"`
+                        }]
+                };
+            }
+            case 'load_camera_preset': {
+                const { name: presetName, animate, duration } = args;
+                const preset = cameraPresets.loadPreset(presetName);
+                if (!preset) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Preset "${presetName}" not found`
+                            }]
+                    };
+                }
+                await bridge.sendCommand({
+                    action: 'setCameraPosition',
+                    position: preset.position,
+                    lookAt: preset.lookAt,
+                    fov: preset.fov,
+                    near: preset.near,
+                    far: preset.far,
+                    animate: animate || false,
+                    duration: duration || 1000
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `OK. Loaded camera preset "${presetName}"${animate ? ' with animation' : ''}`
+                        }]
+                };
+            }
+            case 'list_camera_presets': {
+                const presets = cameraPresets.listPresets();
+                if (presets.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'No camera presets saved yet. Default presets: overhead, front, side, perspective, closeup, wideangle'
+                            }]
+                    };
+                }
+                const list = presets.map(p => `• ${p.name}: [${p.position.join(', ')}]${p.description ? ` - ${p.description}` : ''}`).join('\n');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Camera Presets:\n${list}`
+                        }]
+                };
+            }
+            case 'delete_camera_preset': {
+                const { name: presetName } = args;
+                const deleted = cameraPresets.deletePreset(presetName);
+                if (deleted) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `OK. Deleted preset "${presetName}"`
+                            }]
+                    };
+                }
+                else {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Preset "${presetName}" not found`
+                            }]
+                    };
+                }
+            }
+            case 'animate_camera_presets': {
+                const { presets, duration, hold, repeat } = args;
+                if (!Array.isArray(presets) || presets.length < 2) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: 'Error: Provide at least two preset names to animate.'
+                            }],
+                        isError: true,
+                    };
+                }
+                const missing = presets.filter((presetName) => !cameraPresets.loadPreset(presetName));
+                if (missing.length > 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `Error: Missing presets: ${missing.join(', ')}`
+                            }],
+                        isError: true,
+                    };
+                }
+                const sequence = presets.map((presetName) => cameraPresets.loadPreset(presetName));
+                const stepDuration = typeof duration === 'number' && Number.isFinite(duration) ? duration : 1000;
+                const holdDuration = typeof hold === 'number' && Number.isFinite(hold) ? hold : 0;
+                const repeats = typeof repeat === 'number' && Number.isFinite(repeat) ? Math.max(1, Math.floor(repeat)) : 1;
+                for (let loop = 0; loop < repeats; loop += 1) {
+                    for (const preset of sequence) {
+                        await bridge.sendCommand({
+                            action: 'setCameraPosition',
+                            position: preset.position,
+                            lookAt: preset.lookAt,
+                            fov: preset.fov,
+                            near: preset.near,
+                            far: preset.far,
+                            animate: true,
+                            duration: stepDuration,
+                        });
+                        if (holdDuration > 0) {
+                            await sleep(holdDuration);
+                        }
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `OK. Animated camera through ${presets.length} preset(s) x${repeats}.`
+                        }]
+                };
+            }
+            case 'move_object': {
+                const { name: objName, position } = args;
+                const result = await bridge.sendCommand({ action: 'moveSceneObject', path: objName, position });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: result ? `✅ Moved "${objName}" to [${position.join(', ')}]` : `❌ Object "${objName}" not found`
+                        }]
+                };
+            }
+            case 'spawn_entity': {
+                const { type, name: entityName, position, color, parentName } = args;
+                await bridge.sendCommand({
+                    action: 'addPrimitive',
+                    type: type.toLowerCase(),
+                    name: entityName,
+                    position: position || [0, 0, 0],
+                    material: color ? { color } : undefined,
+                    parent: parentName,
+                });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ Spawned "${entityName}" (${type}) at [${(position || [0, 0, 0]).join(', ')}]`
+                        }]
+                };
+            }
+            case 'destroy_entity': {
+                const { name: entityName } = args;
+                const result = await bridge.sendCommand({ action: 'removeObject', id: entityName, name: entityName });
+                return {
+                    content: [{
+                            type: 'text',
+                            text: result ? `✅ Destroyed "${entityName}"` : `❌ Object "${entityName}" not found`
+                        }]
+                };
+            }
+            case 'set_transform': {
+                const { name: objName, position, rotation, scale } = args;
+                const updates = [];
+                if (position) {
+                    await bridge.sendCommand({ action: 'moveSceneObject', path: objName, position });
+                    updates.push(`position: [${position.join(', ')}]`);
+                }
+                if (rotation) {
+                    await bridge.sendCommand({ action: 'setRotation', id: objName, name: objName, rotation });
+                    updates.push(`rotation: [${rotation.join(', ')}]`);
+                }
+                if (scale) {
+                    await bridge.sendCommand({ action: 'setScale', id: objName, name: objName, scale });
+                    updates.push(`scale: [${scale.join(', ')}]`);
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: updates.length > 0 ? `✅ Updated "${objName}": ${updates.join(', ')}` : `⚠️ No transform properties specified`
+                        }]
+                };
+            }
+            case 'set_visibility': {
+                const { name: objName, visible } = args;
+                await bridge.sendCommand({ action: 'setVisibility', name: objName, visible });
+                return { content: [{ type: 'text', text: `✅ ${visible ? 'Showed' : 'Hid'} "${objName}"` }] };
+            }
+            case 'apply_vibe': {
+                const { vibe } = args;
+                await bridge.sendCommand({ action: 'applyVibe', vibe });
+                return { content: [{ type: 'text', text: `✅ Applied vibe "${vibe}"` }] };
+            }
+            case 'set_environment': {
+                const { preset } = args;
+                await bridge.sendCommand({ action: 'setEnvironment', preset });
+                return { content: [{ type: 'text', text: `✅ Set environment to "${preset}"` }] };
+            }
+            case 'apply_impulse': {
+                const { name: objName, vector } = args;
+                await bridge.sendCommand({ action: 'applyImpulse', name: objName, vector });
+                return { content: [{ type: 'text', text: `✅ Applied impulse [${vector.join(', ')}] to "${objName}"` }] };
+            }
+            case 'set_gravity': {
+                const { vector } = args;
+                await bridge.sendCommand({ action: 'setGravity', vector });
+                return { content: [{ type: 'text', text: `✅ Set global gravity to [${vector.join(', ')}]` }] };
+            }
+            case 'analyze_gltf': {
+                const { path } = args;
+                const result = await analyzeGltf(path);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'validate_asset': {
+                const { path, limits } = args;
+                const result = await validateGltf(path, limits);
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'optimize_gltf': {
+                const { path, output, options } = args;
+                const result = await optimizeGltf(path, {
+                    outputPath: output,
+                    dedup: options?.dedup,
+                    prune: options?.prune,
+                    weld: options?.weld,
+                    quantize: options?.quantize,
+                    simplify: options?.simplify,
+                    textures: options?.textures,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'export_to_svelte': {
+                const { path, output, componentName, assetUrl, mode } = args;
+                const result = await exportToSvelte(path, {
+                    outputPath: output,
+                    componentName,
+                    assetUrl,
+                    mode,
+                });
+                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+            }
+            case 'load_asset': {
+                const { url, name: objName, position, scale } = args;
+                await bridge.sendCommand({ action: 'loadAsset', url, name: objName, position, scale });
+                return { content: [{ type: 'text', text: `✅ Loaded asset "${objName}" from ${url}` }] };
+            }
+            case 'apply_material': {
+                const { name: objName, type, color, preset } = args;
+                await bridge.sendCommand({ action: 'applyMaterial', name: objName, type: type || 'Standard', color, preset });
+                return { content: [{ type: 'text', text: `✅ Applied material to "${objName}"` }] };
+            }
+            case 'get_bridge_status': {
+                return { content: [{ type: 'text', text: JSON.stringify(bridge.getStatus(), null, 2) }] };
+            }
+            default:
+                return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
+        }
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error executing ${name}: ${error instanceof Error ? error.message : String(error)}` }],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('🎮 Threlte MCP Server ready');
+    console.error('   Waiting for game client on ws://localhost:8082');
+}
+main().catch((error) => {
+    console.error('Failed to start MCP server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map