feat: implement WebSocket auto-restart after Unity domain reload and improved windsurfrules to better match this project needs

Author: CoderGamester

.windsurfrules

@@ -1,12 +1,64 @@
-This project is split in 2 parts:
-- The C# Unity Editor package in the Editor/ folder
-- The Node.js server in the Server/ folder.
+## 1. Project Structure
 
-Use WebSockets to communicate between the Editor and the Node.js server.
-For more documentation for the WebSocket library being used in Unity see https://github.com/sta/websocket-sharp/tree/master/websocket-sharp/Server
+- The project consists of two main parts:
+  - Editor/: A C# Unity Editor package that exposes Unity Editor functionality via a WebSocket bridge.
+  - Server/: A Node.js server implementing the Model Context Protocol (MCP), using the official TypeScript SDK.
 
-Minimum supported versions:
-- Unity 2022.3
-- Node.js 18.0.0
+## 2. Communication & Protocol
 
-The MCP Node.js server implements the typescript SDK from https://github.com/modelcontextprotocol/typescript-sdk
+- Communication between the Unity Editor and the Node.js MCP server is handled via WebSockets.
+- The Unity side uses the `websocket-sharp` library: https://github.com/sta/websocket-sharp/tree/master/websocket-sharp/Server
+- The Node.js server uses the `@modelcontextprotocol/sdk` for protocol implementation and exposes tools/resources to LLMs and AI clients.
+
+## 3. Minimum Supported Versions
+
+- Unity: 2022.3 or newer
+- Node.js: 18.0.0 or newer
+
+## 4. Key Components
+
+### Unity Editor Package (Editor/)
+
+- **McpUnityServer**: Singleton entry point for the Unity-side server. Registers tools/resources, manages WebSocket connections, and handles requests from Node.js.
+- **McpUnitySocketHandler**: Handles WebSocket messages/events, dispatches tool/resource calls, and manages client connections.
+- **Tools**: Modular C# classes implementing various Unity actions (e.g., running tests, modifying the scene, package management).
+- **Resources**: Read-only endpoints for querying Unity state (e.g., assets, hierarchy, logs).
+- **Services**: Dependency-injected logic for test running, logging, etc., improving testability and maintainability.
+- **Utils**: Utility classes for configuration, logging, and workspace integration.
+
+### Node.js Server (Server/)
+
+- **index.ts**: Entry point. Sets up the MCP server, registers all tools/resources, and initializes the Unity bridge.
+- **unity/mcpUnity.js**: Handles low-level communication with the Unity Editor via WebSocket.
+- **tools/**: Implements MCP tool endpoints (e.g., run tests, add asset, select object).
+- **resources/**: Implements MCP resource endpoints (e.g., get hierarchy, get logs).
+- **utils/**: Logging and helper utilities.
+- **package.json**: Declares dependencies, including `@modelcontextprotocol/sdk`, `ws`, `express`, etc.
+
+## 5. Integration & Usage
+
+- The Unity Editor package is designed to be used as a package (via UPM or direct import).
+- The Node.js server can be started independently and connects to Unity via WebSocket (port configurable, default 8090).
+- The system is designed for use with LLM-based IDEs (e.g., Windsurf, Cursor, Claude Desktop) to enable AI-powered Unity Editor automation and queries.
+
+## 6. Configuration
+
+- Configuration utilities are provided for generating and injecting MCP config into various IDEs (Cursor, Claude Desktop, Windsurf).
+- Unity-side settings are persisted in `ProjectSettings/McpUnitySettings.json`.
+
+## 7. Extensibility
+
+- Tools and resources can be extended by adding new C# classes (Unity) or TypeScript modules (Node.js).
+- Dependency injection is used on the Unity side for improved modularity and testability.
+
+## 8. References
+
+- MCP Protocol: https://modelcontextprotocol.io
+- TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk
+
+## 9. Conventions
+
+- Use WebSockets for all cross-process communication.
+- Follow the MCP protocol for all tool/resource definitions.
+- All new tools/resources should be registered in both Unity and Node.js server entry points.
+- Follow Conventional Commits for all commit messages.

Editor/UnityBridge/McpUnityEditorWindow.cs

@@ -178,7 +178,9 @@ private void DrawServerTab()
             }
             else
             {
-                EditorGUILayout.LabelField("No clients connected", EditorStyles.centeredGreyMiniLabel);
+                GUIStyle wrapStyle = new GUIStyle(EditorStyles.centeredGreyMiniLabel);
+                wrapStyle.wordWrap = true;
+                GUILayout.Label("No clients connected\nInvoke a tool from the MCP Client to connect", wrapStyle, GUILayout.ExpandWidth(true));
             }
 
             EditorGUILayout.EndVertical();

Editor/UnityBridge/McpUnityServer.cs

@@ -1,16 +1,12 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
-using System.Threading.Tasks;
 using UnityEngine;
 using UnityEditor;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using McpUnity.Tools;
 using McpUnity.Resources;
 using McpUnity.Services;
 using McpUnity.Utils;
-using WebSocketSharp;
 using WebSocketSharp.Server;
 
 namespace McpUnity.Unity
@@ -31,16 +27,24 @@ public class McpUnityServer
         private CancellationTokenSource _cts;
         private TestRunnerService _testRunnerService;
         private ConsoleLogsService _consoleLogsService;
-        private Dictionary<string, string> _clients = new Dictionary<string, string>();
-        
+
         /// <summary>
         /// Static constructor that gets called when Unity loads due to InitializeOnLoad attribute
         /// </summary>
         static McpUnityServer()
         {
             // Initialize the singleton instance when Unity loads
             // This ensures the bridge is available as soon as Unity starts
-            EditorApplication.quitting += () => Instance.StopServer();
+            EditorApplication.quitting += Instance.StopServer;
+
+            // Auto-restart server after domain reload
+            EditorApplication.delayCall += () =>
+            {
+                if (McpUnitySettings.Instance.AutoStartServer)
+                {
+                    Instance.StartServer();
+                }
+            };
         }
 
         /// <summary>
@@ -66,8 +70,8 @@ public static McpUnityServer Instance
         /// <summary>
         /// Dictionary of connected clients with this server
         /// </summary>
-        public Dictionary<string, string> Clients => _clients;
-        
+        public Dictionary<string, string> Clients { get; } = new Dictionary<string, string>();
+
         /// <summary>
         /// Private constructor to enforce singleton pattern
         /// </summary>
@@ -76,13 +80,6 @@ private McpUnityServer()
             InitializeServices();
             RegisterResources();
             RegisterTools();
-            
-            McpLogger.LogInfo($"Created WebSocket server on port {McpUnitySettings.Instance.Port}");
-
-            if (McpUnitySettings.Instance.AutoStartServer || Application.internetReachability != NetworkReachability.NotReachable)
-            {
-                StartServer();
-            }
         }
 
         /// <summary>
@@ -102,7 +99,7 @@ public void StartServer()
                 // Start the server
                 _webSocketServer.Start();
 
-                McpLogger.LogInfo("WebSocket server started");
+                McpLogger.LogInfo($"WebSocket server started on port {McpUnitySettings.Instance.Port}");
             }
             catch (Exception ex)
             {

Server/build/unity/mcpUnity.d.ts

@@ -10,6 +10,7 @@ export declare class McpUnity {
     private ws;
     private pendingRequests;
     private readonly REQUEST_TIMEOUT;
+    private retryDelay;
     constructor(logger: Logger);
     /**
      * Start the Unity connection

Server/build/unity/mcpUnity.js

@@ -9,6 +9,7 @@ export class McpUnity {
     ws = null;
     pendingRequests = new Map();
     REQUEST_TIMEOUT = 10000;
+    retryDelay = 1000;
     constructor(logger) {
         this.logger = logger;
         // Initialize port from environment variable or use default
@@ -87,6 +88,8 @@ export class McpUnity {
             this.ws.onclose = () => {
                 this.logger.debug('WebSocket closed');
                 this.disconnect();
+                //this.logger.debug('WebSocket closed. Reconnecting in', this.retryDelay);
+                //setTimeout(this.connect, this.retryDelay);
             };
         });
     }

Server/src/unity/mcpUnity.ts

@@ -34,6 +34,7 @@ export class McpUnity {
   private ws: WebSocket | null = null;
   private pendingRequests: Map<string, PendingRequest> = new Map<string, PendingRequest>();
   private readonly REQUEST_TIMEOUT = 10000;
+  private retryDelay = 1000;
 
   constructor(logger: Logger) {
     this.logger = logger;
@@ -129,6 +130,8 @@ export class McpUnity {
       this.ws.onclose = () => {
         this.logger.debug('WebSocket closed');
         this.disconnect();
+        //this.logger.debug('WebSocket closed. Reconnecting in', this.retryDelay);
+        //setTimeout(this.connect, this.retryDelay);
       };
     });
   }