@akiojin/unity-mcp-server 2.40.2 → 2.40.3

package/src/tools/scene/loadScene.js

@@ -2,121 +2,123 @@
  * Tool definition for scene_load
  */
 export const loadSceneToolDefinition = {
-    name: 'scene_load',
-    description: 'Load a scene in Unity',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scenePath: {
-                type: 'string',
-                description: 'Full path to the scene file (e.g., "Assets/Scenes/MainMenu.unity")'
-            },
-            sceneName: {
-                type: 'string',
-                description: 'Name of the scene to load (must be in build settings). Use either scenePath or sceneName, not both.'
-            },
-            loadMode: {
-                type: 'string',
-                enum: ['Single', 'Additive'],
-                description: 'How to load the scene. Single replaces current scene(s), Additive adds to current scene(s) (default: Single)'
-            }
-        },
-        required: []
-    }
+  name: 'scene_load',
+  description: 'Load a scene in Unity',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      scenePath: {
+        type: 'string',
+        description: 'Full path to the scene file (e.g., "Assets/Scenes/MainMenu.unity")'
+      },
+      sceneName: {
+        type: 'string',
+        description:
+          'Name of the scene to load (must be in build settings). Use either scenePath or sceneName, not both.'
+      },
+      loadMode: {
+        type: 'string',
+        enum: ['Single', 'Additive'],
+        description:
+          'How to load the scene. Single replaces current scene(s), Additive adds to current scene(s) (default: Single)'
+      }
+    },
+    required: []
+  }
 };
 
 /**
  * Handler for load_scene tool
  */
 export async function loadSceneHandler(unityConnection, args) {
-    try {
-        // Check connection
-        if (!unityConnection.isConnected()) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to load scene: Unity connection not available'
-                    }
-                ],
-                isError: true
-            };
-        }
-
-        // Validate that either scenePath or sceneName is provided
-        if (!args.scenePath && !args.sceneName) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to load scene: Either scenePath or sceneName must be provided'
-                    }
-                ],
-                isError: true
-            };
-        }
+  try {
+    // Check connection
+    if (!unityConnection.isConnected()) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to load scene: Unity connection not available'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Validate that only one is provided
-        if (args.scenePath && args.sceneName) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to load scene: Provide either scenePath or sceneName, not both'
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Validate that either scenePath or sceneName is provided
+    if (!args.scenePath && !args.sceneName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to load scene: Either scenePath or sceneName must be provided'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Validate load mode
-        if (args.loadMode && !['Single', 'Additive'].includes(args.loadMode)) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to load scene: Invalid load mode. Must be "Single" or "Additive"'
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Validate that only one is provided
+    if (args.scenePath && args.sceneName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to load scene: Provide either scenePath or sceneName, not both'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Send command to Unity
-        const result = await unityConnection.sendCommand('scene_load', args);
+    // Validate load mode
+    if (args.loadMode && !['Single', 'Additive'].includes(args.loadMode)) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to load scene: Invalid load mode. Must be "Single" or "Additive"'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Handle Unity response
-        if (result.status === 'error') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to load scene: ${result.error}`
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Send command to Unity
+    const result = await unityConnection.sendCommand('scene_load', args);
 
-        // Success response
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.result.summary || `Scene loaded successfully`
-                }
-            ],
-            isError: false
-        };
-    } catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to load scene: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+    // Handle Unity response
+    if (result.status === 'error') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to load scene: ${result.error}`
+          }
+        ],
+        isError: true
+      };
     }
-}
+
+    // Success response
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.result.summary || `Scene loaded successfully`
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Failed to load scene: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}

package/src/tools/scene/saveScene.js

@@ -2,90 +2,91 @@
  * Tool definition for scene_save
  */
 export const saveSceneToolDefinition = {
-    name: 'scene_save',
-    description: 'Save the current scene in Unity',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scenePath: {
-                type: 'string',
-                description: 'Path where to save the scene. If not provided, saves to current scene path. Required if saveAs is true.'
-            },
-            saveAs: {
-                type: 'boolean',
-                description: 'Whether to save as a new scene (creates a copy). Default: false'
-            }
-        },
-        required: []
-    }
+  name: 'scene_save',
+  description: 'Save the current scene in Unity',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      scenePath: {
+        type: 'string',
+        description:
+          'Path where to save the scene. If not provided, saves to current scene path. Required if saveAs is true.'
+      },
+      saveAs: {
+        type: 'boolean',
+        description: 'Whether to save as a new scene (creates a copy). Default: false'
+      }
+    },
+    required: []
+  }
 };
 
 /**
  * Handler for save_scene tool
  */
 export async function saveSceneHandler(unityConnection, args) {
-    try {
-        // Check connection
-        if (!unityConnection.isConnected()) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to save scene: Unity connection not available'
-                    }
-                ],
-                isError: true
-            };
-        }
-
-        // Validate saveAs requires scenePath
-        if (args.saveAs && !args.scenePath) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to save scene: scenePath is required when saveAs is true'
-                    }
-                ],
-                isError: true
-            };
-        }
+  try {
+    // Check connection
+    if (!unityConnection.isConnected()) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to save scene: Unity connection not available'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Send command to Unity
-        const result = await unityConnection.sendCommand('scene_save', args);
+    // Validate saveAs requires scenePath
+    if (args.saveAs && !args.scenePath) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to save scene: scenePath is required when saveAs is true'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Handle Unity response
-        if (result.status === 'error') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to save scene: ${result.error}`
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Send command to Unity
+    const result = await unityConnection.sendCommand('scene_save', args);
 
-        // Success response
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.result.summary || `Scene saved successfully`
-                }
-            ],
-            isError: false
-        };
-    } catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to save scene: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+    // Handle Unity response
+    if (result.status === 'error') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to save scene: ${result.error}`
+          }
+        ],
+        isError: true
+      };
     }
-}
+
+    // Success response
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.result.summary || `Scene saved successfully`
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Failed to save scene: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}

package/src/tools/system/ping.js

@@ -1,7 +1,4 @@
-import { 
-  ListToolsRequestSchema, 
-  CallToolRequestSchema 
-} from '@modelcontextprotocol/sdk/types.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
 /**
  * Ping tool for testing Unity connection
@@ -22,30 +19,30 @@ export function registerPingTool(server, unityConnection) {
       required: []
     }
   };
-  
+
   // Register list tools handler
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
       tools: [pingTool]
     };
   });
-  
+
   // Register call tool handler
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async request => {
     const { name, arguments: args } = request.params;
-    
+
     if (name === 'system_ping') {
       try {
         // Ensure connected
         if (!unityConnection.isConnected()) {
           await unityConnection.connect();
         }
-        
+
         // Send ping with optional message
         const result = await unityConnection.sendCommand('system_ping', {
           message: args?.message || 'system_ping'
         });
-        
+
         return {
           content: [
             {
@@ -66,7 +63,7 @@ export function registerPingTool(server, unityConnection) {
         };
       }
     }
-    
+
     throw new Error(`Tool not found: ${name}`);
   });
-}
+}

package/src/utils/validators.js

@@ -12,7 +12,7 @@ export function validateVector3(obj, name) {
   if (obj && typeof obj === 'object') {
     const keys = Object.keys(obj);
     const validKeys = ['x', 'y', 'z'];
-    
+
     for (const key of keys) {
       if (!validKeys.includes(key)) {
         throw new Error(`${name} must only contain x, y, z properties`);
@@ -87,4 +87,4 @@ export function validateGameObjectPath(path) {
   if (!path.startsWith('/')) {
     throw new Error('GameObject path must start with /');
   }
-}
+}