feat: add delete scene tool

Author: Snowblaze

Editor/Tools/DeleteSceneTool.cs

@@ -0,0 +1,133 @@
+using System;
+using System.Linq;
+using UnityEngine;
+using UnityEditor;
+using Newtonsoft.Json.Linq;
+using McpUnity.Unity;
+using McpUnity.Utils;
+
+namespace McpUnity.Tools
+{
+    /// <summary>
+    /// Tool for deleting a Unity scene and removing it from Build Settings
+    /// </summary>
+    public class DeleteSceneTool : McpToolBase
+    {
+        public DeleteSceneTool()
+        {
+            Name = "delete_scene";
+            Description = "Deletes a scene by path or name and removes it from Build Settings";
+        }
+
+        /// <summary>
+        /// Execute the DeleteScene tool with the provided parameters
+        /// </summary>
+        /// <param name="parameters">Tool parameters as a JObject</param>
+        public override JObject Execute(JObject parameters)
+        {
+            string scenePath = parameters["scenePath"]?.ToObject<string>();
+            string sceneName = parameters["sceneName"]?.ToObject<string>();
+            string folderPath = parameters["folderPath"]?.ToObject<string>();
+
+            if (string.IsNullOrEmpty(scenePath))
+            {
+                if (string.IsNullOrEmpty(sceneName))
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        "Provide either 'scenePath' or 'sceneName'",
+                        "validation_error"
+                    );
+                }
+
+                // Resolve scene path by name (optionally within folderPath)
+                string filter = $"{sceneName} t:Scene";
+                string[] searchInFolders = null;
+                if (!string.IsNullOrEmpty(folderPath))
+                {
+                    // Ensure folder exists
+                    if (!AssetDatabase.IsValidFolder(folderPath))
+                    {
+                        return McpUnitySocketHandler.CreateErrorResponse(
+                            $"Folder '{folderPath}' does not exist",
+                            "not_found_error"
+                        );
+                    }
+                    searchInFolders = new[] { folderPath };
+                }
+
+                var guids = AssetDatabase.FindAssets(filter, searchInFolders);
+                foreach (var guid in guids)
+                {
+                    var path = AssetDatabase.GUIDToAssetPath(guid);
+                    if (System.IO.Path.GetFileNameWithoutExtension(path) == sceneName)
+                    {
+                        scenePath = path;
+                        break;
+                    }
+                }
+
+                if (string.IsNullOrEmpty(scenePath))
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        $"Scene named '{sceneName}' not found",
+                        "not_found_error"
+                    );
+                }
+            }
+
+            try
+            {
+                // If the scene is open, close it without saving changes
+                var scene = UnityEditor.SceneManagement.EditorSceneManager.GetSceneByPath(scenePath);
+                if (scene.IsValid() && scene.isLoaded)
+                {
+                    UnityEditor.SceneManagement.EditorSceneManager.CloseScene(scene, true);
+                }
+
+                // Remove from Build Settings
+                RemoveSceneFromBuildSettings(scenePath);
+
+                // Delete asset
+                bool deleted = AssetDatabase.DeleteAsset(scenePath);
+                AssetDatabase.Refresh();
+
+                if (!deleted)
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        $"Failed to delete scene at '{scenePath}'",
+                        "delete_error"
+                    );
+                }
+
+                McpLogger.LogInfo($"Deleted scene at path '{scenePath}' and removed from Build Settings");
+
+                return new JObject
+                {
+                    ["success"] = true,
+                    ["type"] = "text",
+                    ["message"] = $"Successfully deleted scene at path '{scenePath}' and removed from Build Settings",
+                    ["scenePath"] = scenePath
+                };
+            }
+            catch (Exception ex)
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    $"Error deleting scene: {ex.Message}",
+                    "scene_delete_error"
+                );
+            }
+        }
+
+        private void RemoveSceneFromBuildSettings(string scenePath)
+        {
+            var scenes = UnityEditor.EditorBuildSettings.scenes;
+            var filtered = scenes.Where(s => s.path != scenePath).ToArray();
+            if (filtered.Length != scenes.Length)
+            {
+                UnityEditor.EditorBuildSettings.scenes = filtered;
+            }
+        }
+    }
+}
+
+

Editor/Tools/DeleteSceneTool.cs.meta

@@ -257,6 +257,10 @@ private void RegisterTools()
             // Register CreateSceneTool
             CreateSceneTool createSceneTool = new CreateSceneTool();
             _tools.Add(createSceneTool.Name, createSceneTool);
+
+            // Register DeleteSceneTool
+            DeleteSceneTool deleteSceneTool = new DeleteSceneTool();
+            _tools.Add(deleteSceneTool.Name, deleteSceneTool);
         }
 
         /// <summary>

Editor/UnityBridge/McpUnityServer.cs

@@ -14,6 +14,7 @@ import { registerUpdateComponentTool } from './tools/updateComponentTool.js';
 import { registerAddAssetToSceneTool } from './tools/addAssetToSceneTool.js';
 import { registerUpdateGameObjectTool } from './tools/updateGameObjectTool.js';
 import { registerCreatePrefabTool } from './tools/createPrefabTool.js';
+import { registerDeleteSceneTool } from './tools/deleteSceneTool.js';
 import { registerGetMenuItemsResource } from './resources/getMenuItemResource.js';
 import { registerGetConsoleLogsResource } from './resources/getConsoleLogsResource.js';
 import { registerGetHierarchyResource } from './resources/getScenesHierarchyResource.js';
@@ -59,6 +60,7 @@ registerAddAssetToSceneTool(server, mcpUnity, toolLogger);
 registerUpdateGameObjectTool(server, mcpUnity, toolLogger);
 registerCreatePrefabTool(server, mcpUnity, toolLogger);
 registerCreateSceneTool(server, mcpUnity, toolLogger);
+registerDeleteSceneTool(server, mcpUnity, toolLogger);
 
 // Register all resources into the MCP server
 registerGetTestsResource(server, mcpUnity, resourceLogger);

Server~/src/index.ts

@@ -0,0 +1,68 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpUnity } from '../unity/mcpUnity.js';
+import { McpUnityError, ErrorType } from '../utils/errors.js';
+import * as z from 'zod';
+import { Logger } from '../utils/logger.js';
+
+const toolName = 'delete_scene';
+const toolDescription = 'Deletes a scene by path or name and removes it from Build Settings';
+
+const paramsSchema = z.object({
+  scenePath: z.string().optional().describe("Full asset path to the scene (e.g., 'Assets/Scenes/MyScene.unity')"),
+  sceneName: z.string().optional().describe('Scene name without extension (used if scenePath not provided)'),
+  folderPath: z.string().optional().describe("Optional folder scope to resolve sceneName under 'Assets'")
+});
+
+export function registerDeleteSceneTool(server: McpServer, mcpUnity: McpUnity, logger: Logger) {
+  logger.info(`Registering tool: ${toolName}`);
+
+  server.tool(
+    toolName,
+    toolDescription,
+    paramsSchema.shape,
+    async (params: any) => {
+      try {
+        logger.info(`Executing tool: ${toolName}`, params);
+        const result = await toolHandler(mcpUnity, params);
+        logger.info(`Tool execution successful: ${toolName}`);
+        return result;
+      } catch (error) {
+        logger.error(`Tool execution failed: ${toolName}`, error);
+        throw error;
+      }
+    }
+  );
+}
+
+async function toolHandler(mcpUnity: McpUnity, params: any) {
+  if (!params.scenePath && !params.sceneName) {
+    throw new McpUnityError(
+      ErrorType.VALIDATION,
+      "Either 'scenePath' or 'sceneName' must be provided"
+    );
+  }
+
+  const response = await mcpUnity.sendRequest({
+    method: toolName,
+    params
+  });
+
+  if (!response.success) {
+    throw new McpUnityError(
+      ErrorType.TOOL_EXECUTION,
+      response.message || 'Failed to delete scene'
+    );
+  }
+
+  return {
+    content: [{
+      type: response.type,
+      text: response.message || 'Successfully deleted scene'
+    }],
+    data: {
+      scenePath: response.scenePath
+    }
+  };
+}
+
+