@akiojin/unity-mcp-server 2.40.2 → 2.40.3

package/src/handlers/ui/UIGetElementStateToolHandler.js

@@ -1,50 +1,42 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class UIGetElementStateToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'ui_get_element_state',
-            'Get detailed state information about UI elements',
-            {
-                type: 'object',
-                properties: {
-                    elementPath: {
-                        type: 'string',
-                        description: 'Full hierarchy path to the UI element'
-                    },
-                    includeChildren: {
-                        type: 'boolean',
-                        description: 'Include child element states (default: false)'
-                    },
-                    includeInteractableInfo: {
-                        type: 'boolean',
-                        description: 'Include interaction capabilities (default: true)'
-                    }
-                },
-                required: ['elementPath']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
-
-    async execute(params) {
-        const {
-            elementPath,
-            includeChildren = false,
-            includeInteractableInfo = true
-        } = params;
-
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
+  constructor(unityConnection) {
+    super('ui_get_element_state', 'Get detailed state information about UI elements', {
+      type: 'object',
+      properties: {
+        elementPath: {
+          type: 'string',
+          description: 'Full hierarchy path to the UI element'
+        },
+        includeChildren: {
+          type: 'boolean',
+          description: 'Include child element states (default: false)'
+        },
+        includeInteractableInfo: {
+          type: 'boolean',
+          description: 'Include interaction capabilities (default: true)'
         }
+      },
+      required: ['elementPath']
+    });
+    this.unityConnection = unityConnection;
+  }
 
-        const result = await this.unityConnection.sendCommand('get_ui_element_state', {
-            elementPath,
-            includeChildren,
-            includeInteractableInfo
-        });
+  async execute(params) {
+    const { elementPath, includeChildren = false, includeInteractableInfo = true } = params;
 
-        return result;
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
-}
+
+    const result = await this.unityConnection.sendCommand('get_ui_element_state', {
+      elementPath,
+      includeChildren,
+      includeInteractableInfo
+    });
+
+    return result;
+  }
+}

package/src/handlers/ui/UISetElementValueToolHandler.js

@@ -1,57 +1,50 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class UISetElementValueToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'ui_set_element_value',
-            'Set values for UI input elements',
-            {
-                type: 'object',
-                properties: {
-                    elementPath: {
-                        type: 'string',
-                        description: 'Full hierarchy path to the UI element'
-                    },
-                    value: {
-                        anyOf: [
-                            { type: 'string' },
-                            { type: 'number' },
-                            { type: 'boolean' },
-                            { type: 'object' },
-                            { type: 'array' },
-                            { type: 'null' }
-                        ],
-                        description: 'New value to set. Supports string, number, boolean, object, array, or null depending on the UI element type.'
-                    },
-                    triggerEvents: {
-                        type: 'boolean',
-                        description: 'Whether to trigger associated events (default: true)'
-                    }
-                },
-                required: ['elementPath', 'value']
-            }
-        );
-        this.unityConnection = unityConnection;
-    }
-
-    async execute(params) {
-        const {
-            elementPath,
-            value,
-            triggerEvents = true
-        } = params;
-
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
+  constructor(unityConnection) {
+    super('ui_set_element_value', 'Set values for UI input elements', {
+      type: 'object',
+      properties: {
+        elementPath: {
+          type: 'string',
+          description: 'Full hierarchy path to the UI element'
+        },
+        value: {
+          anyOf: [
+            { type: 'string' },
+            { type: 'number' },
+            { type: 'boolean' },
+            { type: 'object' },
+            { type: 'array' },
+            { type: 'null' }
+          ],
+          description:
+            'New value to set. Supports string, number, boolean, object, array, or null depending on the UI element type.'
+        },
+        triggerEvents: {
+          type: 'boolean',
+          description: 'Whether to trigger associated events (default: true)'
         }
+      },
+      required: ['elementPath', 'value']
+    });
+    this.unityConnection = unityConnection;
+  }
 
-        const result = await this.unityConnection.sendCommand('set_ui_element_value', {
-            elementPath,
-            value,
-            triggerEvents
-        });
+  async execute(params) {
+    const { elementPath, value, triggerEvents = true } = params;
 
-        return result;
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
+
+    const result = await this.unityConnection.sendCommand('set_ui_element_value', {
+      elementPath,
+      value,
+      triggerEvents
+    });
+
+    return result;
+  }
 }

package/src/handlers/ui/UISimulateInputToolHandler.js

@@ -1,156 +1,154 @@
 import { BaseToolHandler } from '../base/BaseToolHandler.js';
 
 export class UISimulateInputToolHandler extends BaseToolHandler {
-    constructor(unityConnection) {
-        super(
-            'ui_simulate_input',
-            'Simulate complex UI interactions and input sequences',
-            {
+  constructor(unityConnection) {
+    super('ui_simulate_input', 'Simulate complex UI interactions and input sequences', {
+      type: 'object',
+      properties: {
+        // Option 1: Simple single input
+        elementPath: {
+          type: 'string',
+          description: 'Target UI element path (for simple input)'
+        },
+        inputType: {
+          type: 'string',
+          enum: ['click', 'doubleclick', 'rightclick', 'hover', 'focus', 'type'],
+          description: 'Type of input to simulate (for simple input)'
+        },
+        inputData: {
+          type: 'string',
+          description: 'Data for input (e.g., text to type)'
+        },
+        // Option 2: Complex sequence
+        inputSequence: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              type: {
+                type: 'string',
+                description: 'Action type (click, setvalue)'
+              },
+              params: {
                 type: 'object',
-                properties: {
-                    // Option 1: Simple single input
-                    elementPath: {
-                        type: 'string',
-                        description: 'Target UI element path (for simple input)'
-                    },
-                    inputType: {
-                        type: 'string',
-                        enum: ['click', 'doubleclick', 'rightclick', 'hover', 'focus', 'type'],
-                        description: 'Type of input to simulate (for simple input)'
-                    },
-                    inputData: {
-                        type: 'string',
-                        description: 'Data for input (e.g., text to type)'
-                    },
-                    // Option 2: Complex sequence
-                    inputSequence: {
-                        type: 'array',
-                        items: {
-                            type: 'object',
-                            properties: {
-                                type: {
-                                    type: 'string',
-                                    description: 'Action type (click, setvalue)'
-                                },
-                                params: {
-                                    type: 'object',
-                                    description: 'Parameters for the action'
-                                }
-                            },
-                            required: ['type', 'params']
-                        },
-                        description: 'Array of input actions to perform (for complex input)'
-                    },
-                    waitBetween: {
-                        type: 'number',
-                        
-                        minimum: 0,
-                        maximum: 10000,
-                        description: 'Delay between actions in milliseconds'
-                    },
-                    validateState: {
-                        type: 'boolean',
-                        description: 'Validate UI state between actions (default: true)'
-                    }
-                }
-            }
-        );
-        this.unityConnection = unityConnection;
+                description: 'Parameters for the action'
+              }
+            },
+            required: ['type', 'params']
+          },
+          description: 'Array of input actions to perform (for complex input)'
+        },
+        waitBetween: {
+          type: 'number',
+
+          minimum: 0,
+          maximum: 10000,
+          description: 'Delay between actions in milliseconds'
+        },
+        validateState: {
+          type: 'boolean',
+          description: 'Validate UI state between actions (default: true)'
+        }
+      }
+    });
+    this.unityConnection = unityConnection;
+  }
+
+  validate(params) {
+    // Check if using simple mode or complex mode
+    const hasSimpleParams = params.elementPath && params.inputType;
+    const hasComplexParams = params.inputSequence;
+
+    if (!hasSimpleParams && !hasComplexParams) {
+      throw new Error('Either (elementPath + inputType) or inputSequence is required');
     }
 
-    validate(params) {
-        // Check if using simple mode or complex mode
-        const hasSimpleParams = params.elementPath && params.inputType;
-        const hasComplexParams = params.inputSequence;
+    if (hasSimpleParams && hasComplexParams) {
+      throw new Error('Cannot use both simple and complex input modes simultaneously');
+    }
 
-        if (!hasSimpleParams && !hasComplexParams) {
-            throw new Error('Either (elementPath + inputType) or inputSequence is required');
-        }
+    // Validate simple mode
+    if (hasSimpleParams) {
+      if (!params.elementPath || typeof params.elementPath !== 'string') {
+        throw new Error('elementPath must be a non-empty string');
+      }
 
-        if (hasSimpleParams && hasComplexParams) {
-            throw new Error('Cannot use both simple and complex input modes simultaneously');
-        }
+      const validInputTypes = ['click', 'doubleclick', 'rightclick', 'hover', 'focus', 'type'];
+      if (!validInputTypes.includes(params.inputType)) {
+        throw new Error(`inputType must be one of: ${validInputTypes.join(', ')}`);
+      }
 
-        // Validate simple mode
-        if (hasSimpleParams) {
-            if (!params.elementPath || typeof params.elementPath !== 'string') {
-                throw new Error('elementPath must be a non-empty string');
-            }
+      if (params.inputType === 'type' && !params.inputData) {
+        throw new Error('inputData is required when inputType is "type"');
+      }
+    }
 
-            const validInputTypes = ['click', 'doubleclick', 'rightclick', 'hover', 'focus', 'type'];
-            if (!validInputTypes.includes(params.inputType)) {
-                throw new Error(`inputType must be one of: ${validInputTypes.join(', ')}`);
-            }
+    // Validate complex mode
+    if (hasComplexParams) {
+      if (!Array.isArray(params.inputSequence)) {
+        throw new Error('inputSequence must be an array');
+      }
 
-            if (params.inputType === 'type' && !params.inputData) {
-                throw new Error('inputData is required when inputType is "type"');
-            }
-        }
+      if (params.inputSequence.length === 0) {
+        throw new Error('inputSequence must contain at least one action');
+      }
 
-        // Validate complex mode
-        if (hasComplexParams) {
-            if (!Array.isArray(params.inputSequence)) {
-                throw new Error('inputSequence must be an array');
-            }
-
-            if (params.inputSequence.length === 0) {
-                throw new Error('inputSequence must contain at least one action');
-            }
-
-            // Validate each action
-            for (const action of params.inputSequence) {
-                if (!action.type || !action.params) {
-                    throw new Error('Each action must have type and params');
-                }
-            }
+      // Validate each action
+      for (const action of params.inputSequence) {
+        if (!action.type || !action.params) {
+          throw new Error('Each action must have type and params');
         }
+      }
+    }
 
-        // Validate waitBetween range
-        if (params.waitBetween !== undefined) {
-            const wait = params.waitBetween;
-            if (typeof wait !== 'number' || wait < 0 || wait > 10000) {
-                throw new Error('waitBetween must be between 0 and 10000 milliseconds');
-            }
-        }
+    // Validate waitBetween range
+    if (params.waitBetween !== undefined) {
+      const wait = params.waitBetween;
+      if (typeof wait !== 'number' || wait < 0 || wait > 10000) {
+        throw new Error('waitBetween must be between 0 and 10000 milliseconds');
+      }
+    }
+  }
+
+  async execute(params) {
+    const {
+      elementPath,
+      inputType,
+      inputData,
+      inputSequence,
+      waitBetween = 100,
+      validateState = true
+    } = params;
+
+    // Ensure connected
+    if (!this.unityConnection.isConnected()) {
+      await this.unityConnection.connect();
     }
 
-    async execute(params) {
-        const {
-            elementPath,
-            inputType,
-            inputData,
-            inputSequence,
-            waitBetween = 100,
-            validateState = true
-        } = params;
-
-        // Ensure connected
-        if (!this.unityConnection.isConnected()) {
-            await this.unityConnection.connect();
-        }
+    let actualInputSequence;
 
-        let actualInputSequence;
-
-        // Handle simple mode - convert to sequence format
-        if (elementPath && inputType) {
-            actualInputSequence = [{
-                type: inputType,
-                params: {
-                    elementPath,
-                    inputData: inputData || null
-                }
-            }];
-        } else {
-            // Use provided sequence
-            actualInputSequence = inputSequence;
+    // Handle simple mode - convert to sequence format
+    if (elementPath && inputType) {
+      actualInputSequence = [
+        {
+          type: inputType,
+          params: {
+            elementPath,
+            inputData: inputData || null
+          }
         }
+      ];
+    } else {
+      // Use provided sequence
+      actualInputSequence = inputSequence;
+    }
 
-        const result = await this.unityConnection.sendCommand('simulate_ui_input', {
-            inputSequence: actualInputSequence,
-            waitBetween,
-            validateState
-        });
+    const result = await this.unityConnection.sendCommand('simulate_ui_input', {
+      inputSequence: actualInputSequence,
+      waitBetween,
+      validateState
+    });
 
-        return result;
-    }
-}
+    return result;
+  }
+}

package/src/handlers/video/VideoCaptureForToolHandler.js

@@ -12,12 +12,19 @@ export class VideoCaptureForToolHandler extends BaseToolHandler {
       {
         type: 'object',
         properties: {
-          captureMode: { type: 'string', enum: ['game'], description: 'Capture source. Currently only "game" supported.' },
+          captureMode: {
+            type: 'string',
+            enum: ['game'],
+            description: 'Capture source. Currently only "game" supported.'
+          },
           width: { type: 'number', description: 'Output width (0 = default 1280)' },
           height: { type: 'number', description: 'Output height (0 = default 720)' },
           fps: { type: 'number', description: 'Frames per second (default 30)' },
           durationSec: { type: 'number', description: 'Duration to record in seconds' },
-          play: { type: 'boolean', description: 'Enter Play Mode before recording (default true if not already playing)' }
+          play: {
+            type: 'boolean',
+            description: 'Enter Play Mode before recording (default true if not already playing)'
+          }
         },
         required: ['durationSec']
       }
@@ -36,13 +43,18 @@ export class VideoCaptureForToolHandler extends BaseToolHandler {
         try {
           const s0 = await this.unityConnection.sendCommand('playmode_get_state', {});
           needPlay = !(s0 && s0.isPlaying);
-        } catch { needPlay = true; }
+        } catch {
+          needPlay = true;
+        }
       }
       if (needPlay) {
         await this.unityConnection.sendCommand('playmode_play', {});
         for (let i = 0; i < 60; i++) {
           const s = await this.unityConnection.sendCommand('get_editor_state', {});
-          if (s && s.isPlaying) { enteredPlay = true; break; }
+          if (s && s.isPlaying) {
+            enteredPlay = true;
+            break;
+          }
           await sleep(250);
         }
       }
@@ -62,7 +74,8 @@ export class VideoCaptureForToolHandler extends BaseToolHandler {
       }
 
       // Wait until stopped (status reports isRecording=false)
-      const deadline = Date.now() + Math.max(0, Math.floor((params.durationSec || 0) * 1000)) + 1500; // small buffer
+      const deadline =
+        Date.now() + Math.max(0, Math.floor((params.durationSec || 0) * 1000)) + 1500; // small buffer
       let lastStatus = null;
       while (Date.now() < deadline) {
         lastStatus = await this.unityConnection.sendCommand('video_capture_status', {});
@@ -88,9 +101,13 @@ export class VideoCaptureForToolHandler extends BaseToolHandler {
       return { error: e.message, code: 'CLIENT_ERROR' };
     } finally {
       // If we entered play, attempt to leave play (best-effort)
-      try { if (enteredPlay) await this.unityConnection.sendCommand('playmode_stop', {}); } catch {}
+      try {
+        if (enteredPlay) await this.unityConnection.sendCommand('playmode_stop', {});
+      } catch {}
     }
   }
 }
 
-function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}

package/src/lsp/LspRpcClient.js

@@ -18,14 +18,18 @@ export class LspRpcClient {
     this.proc = await this.mgr.ensureStarted();
     // Attach data handler once per process
     if (this.boundOnData) {
-      try { this.proc.stdout.off('data', this.boundOnData); } catch {}
+      try {
+        this.proc.stdout.off('data', this.boundOnData);
+      } catch {}
     }
-    this.boundOnData = (chunk) => this.onData(chunk);
+    this.boundOnData = chunk => this.onData(chunk);
     this.proc.stdout.on('data', this.boundOnData);
     // On process close: reject all pending and reset state
     this.proc.on('close', () => {
       for (const [id, p] of Array.from(this.pending.entries())) {
-        try { p.reject(new Error('LSP process exited')); } catch {}
+        try {
+          p.reject(new Error('LSP process exited'));
+        } catch {}
         this.pending.delete(id);
       }
       this.initialized = false;
@@ -53,7 +57,9 @@ export class LspRpcClient {
           this.pending.get(msg.id).resolve(msg);
           this.pending.delete(msg.id);
         }
-      } catch { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
   }
 
@@ -72,9 +78,9 @@ export class LspRpcClient {
       method: 'initialize',
       params: {
         processId: process.pid,
-        rootUri: this.projectRoot ? ('file://' + String(this.projectRoot).replace(/\\/g, '/')) : null,
+        rootUri: this.projectRoot ? 'file://' + String(this.projectRoot).replace(/\\/g, '/') : null,
         capabilities: {},
-        workspaceFolders: null,
+        workspaceFolders: null
       }
     };
     const timeoutMs = Math.max(5000, Math.min(60000, config.lsp?.requestTimeoutMs || 60000));
@@ -104,12 +110,12 @@ export class LspRpcClient {
     if (!resp) return [];
     const payload = resp.result ?? resp;
     const diagnostics = Array.isArray(payload?.diagnostics) ? payload.diagnostics : [];
-    return diagnostics.map((d) => ({
+    return diagnostics.map(d => ({
       severity: d?.severity,
       message: d?.message,
       id: d?.id,
       line: d?.line,
-      column: d?.column,
+      column: d?.column
     }));
   }
 
@@ -130,17 +136,23 @@ export class LspRpcClient {
       this.writeMessage({ jsonrpc: '2.0', id, method, params });
       return await p;
     } catch (e) {
-      const msg = String(e && e.message || e);
+      const msg = String((e && e.message) || e);
       const recoverable = /timed out|LSP process exited/i.test(msg);
       if (recoverable && attempt === 1) {
         // Auto-reinit and retry once
-        try { await this.mgr.stop(0); } catch {}
-        this.proc = null; this.initialized = false; this.buf = Buffer.alloc(0);
+        try {
+          await this.mgr.stop(0);
+        } catch {}
+        this.proc = null;
+        this.initialized = false;
+        this.buf = Buffer.alloc(0);
         logger.warn(`[csharp-lsp] recoverable error on ${method}: ${msg}. Retrying once...`);
         return await this.#requestWithRetry(method, params, attempt + 1);
       }
       // Standardize error message
-      const hint = recoverable ? 'The server was restarted. Try again if the issue persists.' : 'Check request parameters or increase lsp.requestTimeoutMs.';
+      const hint = recoverable
+        ? 'The server was restarted. Try again if the issue persists.'
+        : 'Check request parameters or increase lsp.requestTimeoutMs.';
       throw new Error(`[${method}] failed: ${msg}. ${hint}`);
     }
   }