@akiojin/unity-mcp-server 2.14.14

package/src/handlers/video/CaptureVideoStatusToolHandler.js

@@ -0,0 +1,30 @@
+/**
+ * Handler for querying video capture status in Unity Editor (via MCP)
+ */
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+export class CaptureVideoStatusToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'capture_video_status',
+      'Get current video recording status.',
+      {
+        type: 'object',
+        properties: {}
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  /** @override */
+  async execute(params, context) {
+    const response = await this.unityConnection.sendCommand('capture_video_status', params || {});
+    if (response.error) {
+      return { error: response.error, code: response.code || 'UNITY_ERROR' };
+    }
+    return {
+      ...response,
+      message: response.message || 'Video recording status retrieved'
+    };
+  }
+}

package/src/handlers/video/CaptureVideoStopToolHandler.js

@@ -0,0 +1,32 @@
+/**
+ * Handler for stopping video capture in Unity Editor (via MCP)
+ */
+import { BaseToolHandler } from '../base/BaseToolHandler.js';
+
+export class CaptureVideoStopToolHandler extends BaseToolHandler {
+  constructor(unityConnection) {
+    super(
+      'capture_video_stop',
+      'Stop current video recording and finalize the file.',
+      {
+        type: 'object',
+        properties: {
+          recordingId: { type: 'string', description: 'Optional. Stop a specific recording session. Defaults to the latest.' }
+        }
+      }
+    );
+    this.unityConnection = unityConnection;
+  }
+
+  /** @override */
+  async execute(params, context) {
+    const response = await this.unityConnection.sendCommand('capture_video_stop', params || {});
+    if (response.error) {
+      return { error: response.error, code: response.code || 'UNITY_ERROR' };
+    }
+    return {
+      ...response,
+      message: response.message || 'Video recording stopped'
+    };
+  }
+}

package/src/lsp/CSharpLspUtils.js

@@ -0,0 +1,134 @@
+import fs from 'fs';
+import path from 'path';
+import { logger } from '../core/config.js';
+import { WORKSPACE_ROOT } from '../core/config.js';
+
+export class CSharpLspUtils {
+  constructor() {}
+
+  detectRid() {
+    if (process.platform === 'win32') return process.arch === 'arm64' ? 'win-arm64' : 'win-x64';
+    if (process.platform === 'darwin') return process.arch === 'arm64' ? 'osx-arm64' : 'osx-x64';
+    return process.arch === 'arm64' ? 'linux-arm64' : 'linux-x64';
+  }
+
+  getDesiredVersion() {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.resolve('mcp-server/package.json'), 'utf8'));
+      return pkg.version;
+    } catch {
+      return null;
+    }
+  }
+
+  getLocalPath(rid) {
+    const root = WORKSPACE_ROOT || process.cwd();
+    const exe = process.platform === 'win32' ? 'server.exe' : 'server';
+    return path.resolve(root, '.unity', 'tools', 'csharp-lsp', rid, exe);
+  }
+
+  getVersionMarkerPath(rid) {
+    const bin = this.getLocalPath(rid);
+    return path.resolve(path.dirname(bin), 'VERSION');
+  }
+
+  readLocalVersion(rid) {
+    try {
+      const m = this.getVersionMarkerPath(rid);
+      if (fs.existsSync(m)) return fs.readFileSync(m, 'utf8').trim();
+    } catch {}
+    return null;
+  }
+
+  writeLocalVersion(rid, version) {
+    try {
+      const m = this.getVersionMarkerPath(rid);
+      fs.writeFileSync(m, String(version || '').trim() + '\n', 'utf8');
+    } catch {}
+  }
+
+  async ensureLocal(rid) {
+    const p = this.getLocalPath(rid);
+    const desired = this.getDesiredVersion();
+    if (!desired) throw new Error('mcp-server version not found; cannot resolve LSP tag');
+    const current = this.readLocalVersion(rid);
+    if (fs.existsSync(p) && current === desired) return p;
+    await this.autoDownload(rid, desired);
+    if (!fs.existsSync(p)) throw new Error('csharp-lsp binary not found after download');
+    this.writeLocalVersion(rid, desired);
+    return p;
+  }
+
+  async autoDownload(rid, version) {
+    const repo = process.env.GITHUB_REPOSITORY || 'akiojin/unity-mcp-server';
+    const tag = `v${version}`;
+    const manifestUrl = `https://github.com/${repo}/releases/download/${tag}/csharp-lsp-manifest.json`;
+    const manifest = await this.fetchJson(manifestUrl);
+    const entry = manifest?.assets?.[rid];
+    if (!entry?.url || !entry?.sha256) throw new Error(`manifest missing entry for ${rid}`);
+
+    const dest = this.getLocalPath(rid);
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    const tmp = dest + '.download';
+    await this.downloadTo(entry.url, tmp);
+    const actual = await this.sha256File(tmp);
+    if (String(actual).toLowerCase() !== String(entry.sha256).toLowerCase()) {
+      try { fs.unlinkSync(tmp); } catch {}
+      throw new Error('checksum mismatch for csharp-lsp asset');
+    }
+    // atomic replace
+    try { fs.renameSync(tmp, dest); } catch (e) {
+      // Windows may need removal before rename
+      try { fs.unlinkSync(dest); } catch {}
+      fs.renameSync(tmp, dest);
+    }
+    try { if (process.platform !== 'win32') fs.chmodSync(dest, 0o755); } catch {}
+    logger.info(`[csharp-lsp] downloaded: ${path.basename(dest)} @ ${path.dirname(dest)}`);
+  }
+
+  async fetchJson(url) {
+    const res = await fetch(url, { headers: { 'User-Agent': 'unity-mcp-server' } });
+    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+    return await res.json();
+  }
+
+  async downloadTo(url, dest) {
+    const res = await fetch(url, { headers: { 'User-Agent': 'unity-mcp-server' } });
+    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+    const file = fs.createWriteStream(dest);
+    const body = res.body;
+    if (body && typeof body.pipe === 'function') {
+      await new Promise((resolve, reject) => {
+        body.pipe(file);
+        body.on('error', reject);
+        file.on('finish', resolve);
+        file.on('error', reject);
+      });
+      return;
+    }
+    try {
+      const { Readable } = await import('node:stream');
+      const nodeStream = Readable.fromWeb(body);
+      await new Promise((resolve, reject) => {
+        nodeStream.pipe(file);
+        nodeStream.on('error', reject);
+        file.on('finish', resolve);
+        file.on('error', reject);
+      });
+    } catch (e) {
+      const ab = await res.arrayBuffer();
+      await fs.promises.writeFile(dest, Buffer.from(ab));
+    }
+  }
+
+  async sha256File(file) {
+    const { createHash } = await import('crypto');
+    return new Promise((resolve, reject) => {
+      const hash = createHash('sha256');
+      const stream = fs.createReadStream(file);
+      stream.on('data', d => hash.update(d));
+      stream.on('error', reject);
+      stream.on('end', () => resolve(hash.digest('hex')));
+    });
+  }
+}

package/src/lsp/LspProcessManager.js

@@ -0,0 +1,60 @@
+import { spawn } from 'child_process';
+import { logger } from '../core/config.js';
+import { CSharpLspUtils } from './CSharpLspUtils.js';
+
+export class LspProcessManager {
+  constructor() {
+    this.proc = null;
+    this.starting = null;
+    this.utils = new CSharpLspUtils();
+  }
+
+  async ensureStarted() {
+    if (this.proc && !this.proc.killed) return this.proc;
+    if (this.starting) return this.starting;
+    this.starting = (async () => {
+      const rid = this.utils.detectRid();
+      const bin = await this.utils.ensureLocal(rid);
+      const proc = spawn(bin, { stdio: ['pipe', 'pipe', 'pipe'] });
+      proc.on('error', (e) => logger.error(`[csharp-lsp] process error: ${e.message}`));
+      proc.on('close', (code, sig) => {
+        logger.warn(`[csharp-lsp] exited code=${code} signal=${sig || ''}`);
+        this.proc = null;
+      });
+      proc.stderr.on('data', d => {
+        const s = String(d || '').trim();
+        if (s) logger.debug(`[csharp-lsp] ${s}`);
+      });
+      this.proc = proc;
+      logger.info(`[csharp-lsp] started (pid=${proc.pid})`);
+      return proc;
+    })();
+    try { return await this.starting; } finally { this.starting = null; }
+  }
+
+  async stop(graceMs = 3000) {
+    if (!this.proc || this.proc.killed) return;
+    const p = this.proc;
+    this.proc = null;
+    try {
+      // Send LSP shutdown/exit if possible
+      const shutdown = (obj) => {
+        try {
+          const json = JSON.stringify(obj);
+          const payload = `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
+          p.stdin.write(payload, 'utf8');
+        } catch {}
+      };
+      shutdown({ jsonrpc: '2.0', id: 1, method: 'shutdown', params: {} });
+      shutdown({ jsonrpc: '2.0', method: 'exit' });
+      p.stdin.end();
+    } catch {}
+    await new Promise((resolve) => {
+      const to = setTimeout(() => {
+        try { p.kill('SIGTERM'); } catch {}
+        setTimeout(() => { try { p.kill('SIGKILL'); } catch {} ; resolve(); }, 1000);
+      }, Math.max(0, graceMs));
+      p.on('close', () => { clearTimeout(to); resolve(); });
+    });
+  }
+}

package/src/lsp/LspRpcClient.js

@@ -0,0 +1,133 @@
+import { LspProcessManager } from './LspProcessManager.js';
+import { config, logger } from '../core/config.js';
+
+export class LspRpcClient {
+  constructor(projectRoot = null) {
+    this.mgr = new LspProcessManager();
+    this.proc = null;
+    this.seq = 1;
+    this.pending = new Map();
+    this.buf = Buffer.alloc(0);
+    this.initialized = false;
+    this.projectRoot = projectRoot;
+    this.boundOnData = null;
+  }
+
+  async ensure() {
+    if (this.proc && !this.proc.killed) return this.proc;
+    this.proc = await this.mgr.ensureStarted();
+    // Attach data handler once per process
+    if (this.boundOnData) {
+      try { this.proc.stdout.off('data', this.boundOnData); } catch {}
+    }
+    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 {}
+        this.pending.delete(id);
+      }
+      this.initialized = false;
+      this.proc = null;
+    });
+    if (!this.initialized) await this.initialize();
+    return this.proc;
+  }
+
+  onData(chunk) {
+    this.buf = Buffer.concat([this.buf, Buffer.from(chunk)]);
+    while (true) {
+      const headerEnd = this.buf.indexOf('\r\n\r\n');
+      if (headerEnd < 0) break;
+      const header = this.buf.slice(0, headerEnd).toString('utf8');
+      const m = header.match(/Content-Length:\s*(\d+)/i);
+      const len = m ? parseInt(m[1], 10) : 0;
+      const total = headerEnd + 4 + len;
+      if (this.buf.length < total) break;
+      const jsonBuf = this.buf.slice(headerEnd + 4, total);
+      this.buf = this.buf.slice(total);
+      try {
+        const msg = JSON.parse(jsonBuf.toString('utf8'));
+        if (msg.id && this.pending.has(msg.id)) {
+          this.pending.get(msg.id).resolve(msg);
+          this.pending.delete(msg.id);
+        }
+      } catch { /* ignore */ }
+    }
+  }
+
+  writeMessage(obj) {
+    const json = JSON.stringify(obj);
+    const payload = `Content-Length: ${Buffer.byteLength(json, 'utf8')}\r\n\r\n${json}`;
+    this.proc.stdin.write(payload, 'utf8');
+  }
+
+  async initialize() {
+    await this.ensure();
+    const id = this.seq++;
+    const req = {
+      jsonrpc: '2.0',
+      id,
+      method: 'initialize',
+      params: {
+        processId: process.pid,
+        rootUri: this.projectRoot ? ('file://' + String(this.projectRoot).replace(/\\/g, '/')) : null,
+        capabilities: {},
+        workspaceFolders: null,
+      }
+    };
+    const timeoutMs = Math.max(5000, Math.min(60000, config.lsp?.requestTimeoutMs || 60000));
+    const p = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`initialize timed out after ${timeoutMs} ms`));
+        }
+      }, timeoutMs);
+    });
+    this.writeMessage(req);
+    const resp = await p; // ignore result contents for stub
+    // send initialized notification
+    this.writeMessage({ jsonrpc: '2.0', method: 'initialized', params: {} });
+    this.initialized = true;
+    return resp;
+  }
+
+  async request(method, params) {
+    return await this.#requestWithRetry(method, params, 1);
+  }
+
+  async #requestWithRetry(method, params, attempt) {
+    await this.ensure();
+    const id = this.seq++;
+    const timeoutMs = Math.max(1000, Math.min(300000, config.lsp?.requestTimeoutMs || 60000));
+    const p = new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`${method} timed out after ${timeoutMs} ms`));
+        }
+      }, timeoutMs);
+    });
+    try {
+      this.writeMessage({ jsonrpc: '2.0', id, method, params });
+      return await p;
+    } catch (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);
+        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.';
+      throw new Error(`[${method}] failed: ${msg}. ${hint}`);
+    }
+  }
+}

package/src/tools/analysis/analyzeSceneContents.js

@@ -0,0 +1,100 @@
+/**
+ * Tool definition for analyze_scene_contents
+ */
+export const analyzeSceneContentsToolDefinition = {
+    name: 'analyze_scene_contents',
+    description: 'Analyze current scene: object counts, types, prefabs, and memory stats.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            includeInactive: {
+                type: 'boolean',
+                description: 'Include inactive objects in analysis. Default: true'
+            },
+            groupByType: {
+                type: 'boolean',
+                description: 'Group results by component types. Default: true'
+            },
+            includePrefabInfo: {
+                type: 'boolean',
+                description: 'Include prefab connection info. Default: true'
+            },
+            includeMemoryInfo: {
+                type: 'boolean',
+                description: 'Include memory usage estimates. Default: false'
+            }
+        },
+        required: []
+    }
+};
+
+/**
+ * Handler for analyze_scene_contents tool
+ */
+export async function analyzeSceneContentsHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to analyze scene: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Send command to Unity with provided parameters
+        const result = await unityConnection.sendCommand('analyze_scene_contents', args);
+
+        // The unityConnection.sendCommand already extracts the result field
+        // from the response, so we access properties directly on result
+        if (!result || typeof result === 'string') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to analyze scene: Invalid response format`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Check if result has error property (error response from Unity)
+        if (result.error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to analyze scene: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Success response - result is already the unwrapped data
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.summary || 'Scene analysis complete'
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to analyze scene: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}

package/src/tools/analysis/findByComponent.js

@@ -0,0 +1,87 @@
+/**
+ * Tool definition for find_by_component
+ */
+export const findByComponentToolDefinition = {
+    name: 'find_by_component',
+    description: 'Find GameObjects that have a specific component type (scene/prefabs/all).',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            componentType: {
+                type: 'string',
+                description: 'Component type to search for (e.g., "Light", "Collider", "AudioSource")'
+            },
+            includeInactive: {
+                type: 'boolean',
+                description: 'Include inactive GameObjects. Default: true'
+            },
+            searchScope: {
+                type: 'string',
+                enum: ['scene', 'prefabs', 'all'],
+                description: 'Where to search: current scene, prefabs, or all. Default: "scene"'
+            },
+            matchExactType: {
+                type: 'boolean',
+                description: 'Match exact type only (not derived types). Default: true'
+            }
+        },
+        required: ['componentType']
+    }
+};
+
+/**
+ * Handler for find_by_component tool
+ */
+export async function findByComponentHandler(unityConnection, args) {
+    try {
+        // Check connection
+        if (!unityConnection.isConnected()) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Failed to find GameObjects: Unity connection not available'
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Send command to Unity
+        const result = await unityConnection.sendCommand('find_by_component', args);
+
+        // Handle Unity response
+        if (result.status === 'error') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Failed to find GameObjects: ${result.error}`
+                    }
+                ],
+                isError: true
+            };
+        }
+
+        // Success response
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result.result.summary || `Found ${result.result.totalFound} GameObjects`
+                }
+            ],
+            isError: false
+        };
+    } catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to find GameObjects: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}