@akiojin/unity-mcp-server 2.14.14

package/src/tools/scene/getSceneInfo.js

@@ -0,0 +1,95 @@
+/**
+ * Tool definition for get_scene_info
+ */
+export const getSceneInfoToolDefinition = {
+    name: 'get_scene_info',
+    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
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('get_scene_info', args);
+
+        // 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

@@ -0,0 +1,82 @@
+/**
+ * Tool definition for list_scenes
+ */
+export const listScenesToolDefinition = {
+    name: 'list_scenes',
+    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('list_scenes', args);
+
+        // 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
+        };
+    }
+}

package/src/tools/scene/loadScene.js

@@ -0,0 +1,122 @@
+/**
+ * Tool definition for load_scene
+ */
+export const loadSceneToolDefinition = {
+    name: 'load_scene',
+    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
+            };
+        }
+
+        // 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 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
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('load_scene', args);
+
+        // 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

@@ -0,0 +1,91 @@
+/**
+ * Tool definition for save_scene
+ */
+export const saveSceneToolDefinition = {
+    name: 'save_scene',
+    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
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('save_scene', args);
+
+        // 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

@@ -0,0 +1,72 @@
+import { 
+  ListToolsRequestSchema, 
+  CallToolRequestSchema 
+} from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Ping tool for testing Unity connection
+ */
+export function registerPingTool(server, unityConnection) {
+  // Tool definition
+  const pingTool = {
+    name: 'ping',
+    description: 'Test connection to Unity Editor',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          description: 'Optional message to echo back'
+        }
+      },
+      required: []
+    }
+  };
+  
+  // Register list tools handler
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [pingTool]
+    };
+  });
+  
+  // Register call tool handler
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    
+    if (name === 'ping') {
+      try {
+        // Ensure connected
+        if (!unityConnection.isConnected()) {
+          await unityConnection.connect();
+        }
+        
+        // Send ping with optional message
+        const result = await unityConnection.sendCommand('ping', {
+          message: args?.message || 'ping'
+        });
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Unity responded: ${result.message} (echo: ${result.echo || args?.message || 'ping'})`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Failed to ping Unity: ${error.message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    
+    throw new Error(`Tool not found: ${name}`);
+  });
+}

package/src/tools/video/recordFor.js

@@ -0,0 +1,31 @@
+import { UnityConnection } from '../../core/unityConnection.js';
+import { CaptureVideoForToolHandler } from '../../handlers/video/CaptureVideoForToolHandler.js';
+
+async function main() {
+  const unity = new UnityConnection();
+  try { await unity.connect(); } catch (e) { console.error('connect failed:', e.message); process.exit(1); }
+  try {
+    const ts = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+    const outputPath = `Assets/Screenshots/recordings/mcp_for_${ts}.mp4`;
+    const handler = new CaptureVideoForToolHandler(unity);
+    const result = await handler.execute({
+        captureMode: 'game',
+        width: 1280,
+        height: 720,
+        fps: 30,
+        durationSec: 2,
+        play: true
+    });
+    if (result && result.error) {
+      console.error('capture_video_for error:', result.error);
+    } else {
+      console.log('capture_video_for ok:', result && result.outputPath);
+    }
+  } catch (e) {
+    console.error('recordFor error:', e.message);
+  } finally {
+    unity.disconnect();
+  }
+}
+
+main();

package/src/tools/video/recordPlayMode.js

@@ -0,0 +1,61 @@
+import { UnityConnection } from '../../core/unityConnection.js';
+import { config } from '../../core/config.js';
+
+async function main() {
+  const unity = new UnityConnection();
+  try {
+    await unity.connect();
+  } catch (e) {
+    console.error('[recordPlayMode] Failed to connect to Unity:', e.message);
+    process.exit(1);
+  }
+
+  try {
+    // Enter Play Mode
+    await unity.sendCommand('play_game', {});
+    // Domain reload causes disconnect. Reconnect and wait for play.
+    for (let i = 0; i < 60; i++) {
+      if (!unity.isConnected()) {
+        try { await unity.connect(); } catch {}
+      }
+      try {
+        const s = await unity.sendCommand('get_editor_state', {});
+        if (s && s.isPlaying) break;
+      } catch {}
+      await new Promise(r => setTimeout(r, 500));
+    }
+
+    // Start recording
+    const start = await unity.sendCommand('capture_video_start', {
+      captureMode: 'game',
+      width: 1280,
+      height: 720,
+      fps: 30,
+      maxDurationSec: 3
+    });
+    if (start && start.error) {
+      console.error('[recordPlayMode] start error:', start.error);
+    }
+
+    // Poll status a few times
+    for (let i = 0; i < 16; i++) {
+      const st = await unity.sendCommand('capture_video_status', {});
+      // console.log('[recordPlayMode] status', st);
+      await new Promise(r => setTimeout(r, 250));
+    }
+
+    // Ensure stopped
+    await unity.sendCommand('capture_video_stop', {});
+
+  } catch (e) {
+    console.error('[recordPlayMode] error:', e.message);
+  } finally {
+    try {
+      if (!unity.isConnected()) { await unity.connect(); }
+      await unity.sendCommand('stop_game', {});
+    } catch {}
+    unity.disconnect();
+  }
+}
+
+main();

package/src/utils/csharpParse.js

@@ -0,0 +1,88 @@
+// Lightweight C# symbol extractor for Node-side fallback (not Roslyn-accurate)
+export function parseFileSymbols(relPath, text) {
+  const lines = text.split('\n');
+  const result = { path: relPath, symbols: [] };
+  const nsRx = /^\s*namespace\s+([A-Za-z0-9_.]+)/;
+  const typeRx = /^\s*(?:public|internal|protected|private|abstract|sealed|static|partial|new|readonly|\s)*\s*(class|struct|interface|enum)\s+([A-Za-z0-9_]+)/;
+  const methodRx = /^\s*(?:public|internal|protected|private|static|virtual|override|async|sealed|extern|unsafe|new|readonly|\s)+[A-Za-z0-9_<>,\[\]\?\(\)\.:\s]+\s+([A-Za-z0-9_]+)\s*\(([^)]*)\)\s*(?:\{|=>|;)/;
+  const propRx = /^\s*(?:public|internal|protected|private|static|virtual|override|sealed|new|readonly|\s)+[A-Za-z0-9_<>,\[\]\?\.:\s]+\s+([A-Za-z0-9_]+)\s*\{/;
+
+  const nsStack = [];
+  const typeStack = [];
+  let braceDepth = 0;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const nsM = line.match(nsRx);
+    if (nsM) nsStack.push({ name: nsM[1], line: i + 1 });
+
+    const tM = line.match(typeRx);
+    if (tM) {
+      const kind = tM[1];
+      const name = tM[2];
+      typeStack.push({ kind, name, startLine: i + 1, braceDepthAtStart: braceDepth });
+      result.symbols.push({
+        name,
+        kind,
+        namespace: nsStack.map(n => n.name).join('.'),
+        container: typeStack.length > 1 ? typeStack[typeStack.length - 2].name : null,
+        startLine: i + 1,
+        endLine: 0,
+        startColumn: 1,
+        endColumn: 1,
+      });
+    }
+
+    const mM = line.match(methodRx);
+    if (mM) {
+      const name = mM[1];
+      result.symbols.push({
+        name,
+        kind: 'method',
+        namespace: nsStack.map(n => n.name).join('.'),
+        container: typeStack.length ? typeStack[typeStack.length - 1].name : null,
+        startLine: i + 1,
+        endLine: i + 1,
+        startColumn: 1,
+        endColumn: 1,
+      });
+    }
+
+    const pM = line.match(propRx);
+    if (pM) {
+      const name = pM[1];
+      result.symbols.push({
+        name,
+        kind: 'property',
+        namespace: nsStack.map(n => n.name).join('.'),
+        container: typeStack.length ? typeStack[typeStack.length - 1].name : null,
+        startLine: i + 1,
+        endLine: i + 1,
+        startColumn: 1,
+        endColumn: 1,
+      });
+    }
+
+    // brace accounting
+    for (const ch of line) {
+      if (ch === '{') braceDepth++;
+      else if (ch === '}') braceDepth--;
+    }
+    // close types whose body ended
+    while (typeStack.length && braceDepth < typeStack[typeStack.length - 1].braceDepthAtStart) {
+      const closed = typeStack.pop();
+      // set endLine for the last matching symbol
+      for (let j = result.symbols.length - 1; j >= 0; j--) {
+        const s = result.symbols[j];
+        if (s.kind === closed.kind && s.name === closed.name && s.endLine === 0) { s.endLine = i + 1; break; }
+      }
+    }
+  }
+  const last = Math.max(1, lines.length);
+  for (const s of result.symbols) {
+    if (!s.endLine) s.endLine = last;
+    if (!s.endColumn) s.endColumn = 1;
+  }
+  return result;
+}
+