@akiojin/unity-mcp-server 2.40.2 → 2.40.3

package/src/tools/scene/createScene.js

@@ -2,111 +2,112 @@
  * Tool definition for scene_create
  */
 export const createSceneToolDefinition = {
-    name: 'scene_create',
-    description: 'Create a new scene in Unity',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            sceneName: {
-                type: 'string',
-                description: 'Name of the scene to create'
-            },
-            path: {
-                type: 'string',
-                description: 'Path where the scene should be saved (e.g., "Assets/Scenes/"). If not specified, defaults to "Assets/Scenes/"'
-            },
-            loadScene: {
-                type: 'boolean',
-                description: 'Whether to load the scene after creation (default: true)'
-            },
-            addToBuildSettings: {
-                type: 'boolean',
-                description: 'Whether to add the scene to build settings (default: false)'
-            }
-        },
-        required: ['sceneName']
-    }
+  name: 'scene_create',
+  description: 'Create a new scene in Unity',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      sceneName: {
+        type: 'string',
+        description: 'Name of the scene to create'
+      },
+      path: {
+        type: 'string',
+        description:
+          'Path where the scene should be saved (e.g., "Assets/Scenes/"). If not specified, defaults to "Assets/Scenes/"'
+      },
+      loadScene: {
+        type: 'boolean',
+        description: 'Whether to load the scene after creation (default: true)'
+      },
+      addToBuildSettings: {
+        type: 'boolean',
+        description: 'Whether to add the scene to build settings (default: false)'
+      }
+    },
+    required: ['sceneName']
+  }
 };
 
 /**
  * Handler for create_scene tool
  */
 export async function createSceneHandler(unityConnection, args) {
-    try {
-        // Check connection
-        if (!unityConnection.isConnected()) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to create scene: Unity connection not available'
-                    }
-                ],
-                isError: true
-            };
-        }
-
-        // Validate scene name
-        if (!args.sceneName || args.sceneName.trim() === '') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to create scene: Scene name cannot be empty'
-                    }
-                ],
-                isError: true
-            };
-        }
+  try {
+    // Check connection
+    if (!unityConnection.isConnected()) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to create scene: Unity connection not available'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Check for invalid characters in scene name
-        if (args.sceneName.includes('/') || args.sceneName.includes('\\')) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to create scene: Scene name contains invalid characters'
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Validate scene name
+    if (!args.sceneName || args.sceneName.trim() === '') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to create scene: Scene name cannot be empty'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Send command to Unity
-        const result = await unityConnection.sendCommand('scene_create', args);
+    // Check for invalid characters in scene name
+    if (args.sceneName.includes('/') || args.sceneName.includes('\\')) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to create scene: Scene name contains invalid characters'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Handle Unity response
-        if (result.status === 'error') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to create scene: ${result.error}`
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Send command to Unity
+    const result = await unityConnection.sendCommand('scene_create', args);
 
-        // Success response
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.result.summary || `Scene created successfully`
-                }
-            ],
-            isError: false
-        };
-    } catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to create scene: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+    // Handle Unity response
+    if (result.status === 'error') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to create scene: ${result.error}`
+          }
+        ],
+        isError: true
+      };
     }
-}
+
+    // Success response
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.result.summary || `Scene created successfully`
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Failed to create scene: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}

package/src/tools/scene/getSceneInfo.js

@@ -2,94 +2,95 @@
  * Tool definition for scene_info_get
  */
 export const getSceneInfoToolDefinition = {
-    name: 'scene_info_get',
-    description: 'Get detailed information about a scene',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            scenePath: {
-                type: 'string',
-                description: 'Full path to the scene file. If not provided, gets info about current scene.'
-            },
-            sceneName: {
-                type: 'string',
-                description: 'Name of the scene. Use either scenePath or sceneName, not both.'
-            },
-            includeGameObjects: {
-                type: 'boolean',
-                description: 'Include list of root GameObjects in the scene (only for loaded scenes). Default: false'
-            }
-        },
-        required: []
-    }
+  name: 'scene_info_get',
+  description: 'Get detailed information about a scene',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      scenePath: {
+        type: 'string',
+        description: 'Full path to the scene file. If not provided, gets info about current scene.'
+      },
+      sceneName: {
+        type: 'string',
+        description: 'Name of the scene. Use either scenePath or sceneName, not both.'
+      },
+      includeGameObjects: {
+        type: 'boolean',
+        description:
+          'Include list of root GameObjects in the scene (only for loaded scenes). Default: false'
+      }
+    },
+    required: []
+  }
 };
 
 /**
  * Handler for get_scene_info tool
  */
 export async function getSceneInfoHandler(unityConnection, args) {
-    try {
-        // Check connection
-        if (!unityConnection.isConnected()) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to get scene info: Unity connection not available'
-                    }
-                ],
-                isError: true
-            };
-        }
-
-        // Validate that only one identifier is provided if any
-        if (args.scenePath && args.sceneName) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to get scene info: Provide either scenePath or sceneName, not both'
-                    }
-                ],
-                isError: true
-            };
-        }
+  try {
+    // Check connection
+    if (!unityConnection.isConnected()) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to get scene info: Unity connection not available'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Send command to Unity
-        const result = await unityConnection.sendCommand('scene_info_get', args);
+    // Validate that only one identifier is provided if any
+    if (args.scenePath && args.sceneName) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to get scene info: Provide either scenePath or sceneName, not both'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Handle Unity response
-        if (result.status === 'error') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to get scene info: ${result.error}`
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Send command to Unity
+    const result = await unityConnection.sendCommand('scene_info_get', args);
 
-        // Success response
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.result.summary || `Scene information retrieved`
-                }
-            ],
-            isError: false
-        };
-    } catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to get scene info: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+    // Handle Unity response
+    if (result.status === 'error') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to get scene info: ${result.error}`
+          }
+        ],
+        isError: true
+      };
     }
-}
+
+    // Success response
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.result.summary || `Scene information retrieved`
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Failed to get scene info: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}

package/src/tools/scene/listScenes.js

@@ -2,81 +2,82 @@
  * Tool definition for scene_list
  */
 export const listScenesToolDefinition = {
-    name: 'scene_list',
-    description: 'List all scenes in the Unity project',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            includeLoadedOnly: {
-                type: 'boolean',
-                description: 'Only include currently loaded scenes (default: false)'
-            },
-            includeBuildScenesOnly: {
-                type: 'boolean',
-                description: 'Only include scenes in build settings (default: false)'
-            },
-            includePath: {
-                type: 'string',
-                description: 'Filter scenes by path pattern (e.g., "Levels" to find scenes in Levels folder)'
-            }
-        },
-        required: []
-    }
+  name: 'scene_list',
+  description: 'List all scenes in the Unity project',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      includeLoadedOnly: {
+        type: 'boolean',
+        description: 'Only include currently loaded scenes (default: false)'
+      },
+      includeBuildScenesOnly: {
+        type: 'boolean',
+        description: 'Only include scenes in build settings (default: false)'
+      },
+      includePath: {
+        type: 'string',
+        description:
+          'Filter scenes by path pattern (e.g., "Levels" to find scenes in Levels folder)'
+      }
+    },
+    required: []
+  }
 };
 
 /**
  * Handler for list_scenes tool
  */
 export async function listScenesHandler(unityConnection, args) {
-    try {
-        // Check connection
-        if (!unityConnection.isConnected()) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: 'Failed to list scenes: Unity connection not available'
-                    }
-                ],
-                isError: true
-            };
-        }
-
-        // Send command to Unity
-        const result = await unityConnection.sendCommand('scene_list', args);
+  try {
+    // Check connection
+    if (!unityConnection.isConnected()) {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: 'Failed to list scenes: Unity connection not available'
+          }
+        ],
+        isError: true
+      };
+    }
 
-        // Handle Unity response
-        if (result.status === 'error') {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Failed to list scenes: ${result.error}`
-                    }
-                ],
-                isError: true
-            };
-        }
+    // Send command to Unity
+    const result = await unityConnection.sendCommand('scene_list', args);
 
-        // Success response
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: result.result.summary || `Found ${result.result.totalCount} scenes`
-                }
-            ],
-            isError: false
-        };
-    } catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Failed to list scenes: ${error.message}`
-                }
-            ],
-            isError: true
-        };
+    // Handle Unity response
+    if (result.status === 'error') {
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Failed to list scenes: ${result.error}`
+          }
+        ],
+        isError: true
+      };
     }
-}
+
+    // Success response
+    return {
+      content: [
+        {
+          type: 'text',
+          text: result.result.summary || `Found ${result.result.totalCount} scenes`
+        }
+      ],
+      isError: false
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Failed to list scenes: ${error.message}`
+        }
+      ],
+      isError: true
+    };
+  }
+}