@akiojin/unity-mcp-server 3.1.0 → 3.2.0

package/bin/unity-mcp-server.js

@@ -34,7 +34,7 @@ const args = process.argv.slice(2);
 const command = args[0] && !args[0].startsWith('--') ? args[0] : null;
 const rest = command ? args.slice(1) : args;
 
-let httpEnabled = false;
+let httpEnabled;
 let httpPort;
 let stdioEnabled = true;
 let telemetryEnabled;
@@ -114,11 +114,12 @@ async function main() {
 
     // Start MCP server (dynamic import)
     const { startServer } = await import('../src/core/server.js');
+    const http = {};
+    if (httpEnabled !== undefined) http.enabled = httpEnabled;
+    if (httpPort !== undefined) http.port = httpPort;
+
     await startServer({
-      http: {
-        enabled: httpEnabled,
-        port: httpPort
-      },
+      http: Object.keys(http).length > 0 ? http : undefined,
       telemetry: telemetryEnabled === undefined ? undefined : { enabled: telemetryEnabled },
       stdioEnabled
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akiojin/unity-mcp-server",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "MCP server and Unity Editor bridge — enables AI assistants to control Unity for AI-assisted workflows",
   "type": "module",
   "main": "src/core/server.js",

package/src/core/config.js

@@ -1,12 +1,8 @@
 import fs from 'fs';
-import os from 'os';
 import path from 'path';
 import * as findUpPkg from 'find-up';
 import { MCPLogger } from './mcpLogger.js';
 
-// Diagnostic log: confirm module loading reached this point
-process.stderr.write('[unity-mcp-server] Config module loading...\n');
-
 function findUpSyncCompat(matcher, options = {}) {
   if (typeof matcher === 'function') {
     let dir = options.cwd || process.cwd();
@@ -39,6 +35,30 @@ function merge(a, b) {
   return out;
 }
 
+function parseBoolEnv(value) {
+  if (typeof value !== 'string') return undefined;
+  const v = value.trim().toLowerCase();
+  if (v === '') return undefined;
+  if (v === '1' || v === 'true' || v === 'yes' || v === 'y' || v === 'on') return true;
+  if (v === '0' || v === 'false' || v === 'no' || v === 'n' || v === 'off') return false;
+  return undefined;
+}
+
+function parseIntEnv(value) {
+  if (typeof value !== 'string') return undefined;
+  const v = value.trim();
+  if (v === '') return undefined;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function envString(key) {
+  const raw = process.env[key];
+  if (typeof raw !== 'string') return undefined;
+  const v = raw.trim();
+  return v.length > 0 ? v : undefined;
+}
+
 function resolvePackageVersion() {
   const candidates = [];
 
@@ -71,16 +91,23 @@ function resolvePackageVersion() {
 const baseConfig = {
   // Unity connection settings
   unity: {
-    unityHost: null,
-    mcpHost: null,
-    bindHost: null,
+    unityHost: 'localhost',
+    mcpHost: 'localhost',
+    bindHost: 'localhost',
     port: 6400,
     reconnectDelay: 1000,
     maxReconnectDelay: 30000,
     reconnectBackoffMultiplier: 2,
+    connectTimeout: 3000,
     commandTimeout: 30000
   },
 
+  // Project settings (primarily for code index paths)
+  project: {
+    root: null,
+    codeIndexRoot: null
+  },
+
   // Server settings
   server: {
     name: 'unity-mcp-server',
@@ -136,83 +163,124 @@ const baseConfig = {
   }
 };
 
-/**
- * External config resolution:
- * - Uses the nearest `.unity/config.json` found by walking up from the current working directory.
- * - Intentionally ignores `~/.unity/config.json` (user-global).
- */
-function loadExternalConfig() {
-  if (typeof findUpSyncCompat !== 'function') {
-    return {};
+function loadEnvConfig() {
+  const unityHost = envString('UNITY_MCP_UNITY_HOST');
+  const mcpHost = envString('UNITY_MCP_MCP_HOST');
+  const unityPort = parseIntEnv(process.env.UNITY_MCP_PORT);
+
+  const projectRoot = envString('UNITY_PROJECT_ROOT');
+
+  const logLevel = envString('UNITY_MCP_LOG_LEVEL');
+
+  const httpEnabled = parseBoolEnv(process.env.UNITY_MCP_HTTP_ENABLED);
+  const httpPort = parseIntEnv(process.env.UNITY_MCP_HTTP_PORT);
+
+  const telemetryEnabled = parseBoolEnv(process.env.UNITY_MCP_TELEMETRY_ENABLED);
+  const lspRequestTimeoutMs = parseIntEnv(process.env.UNITY_MCP_LSP_REQUEST_TIMEOUT_MS);
+
+  const out = {};
+
+  if (unityHost || mcpHost || unityPort !== undefined) {
+    out.unity = {};
+    if (unityHost) out.unity.unityHost = unityHost;
+    if (mcpHost) out.unity.mcpHost = mcpHost;
+    if (unityPort !== undefined) out.unity.port = unityPort;
+    if (out.unity.unityHost) out.unity.bindHost = out.unity.unityHost;
   }
-  let userGlobalPath = null;
-  try {
-    const homeDir = os.homedir();
-    userGlobalPath = homeDir ? path.resolve(homeDir, '.unity', 'config.json') : null;
-  } catch {}
 
-  const projectPath = findUpSyncCompat(
-    directory => {
-      const candidate = path.resolve(directory, '.unity', 'config.json');
-      if (userGlobalPath && path.resolve(candidate) === userGlobalPath) return undefined;
-      return fs.existsSync(candidate) ? candidate : undefined;
-    },
-    { cwd: process.cwd() }
-  );
+  if (projectRoot) {
+    out.project = {};
+    if (projectRoot) out.project.root = projectRoot;
+  }
 
-  if (!projectPath) return {};
-  try {
-    const raw = fs.readFileSync(projectPath, 'utf8');
-    const json = JSON.parse(raw);
-    const out = json && typeof json === 'object' ? json : {};
-    out.__configPath = projectPath;
-    return out;
-  } catch (e) {
-    return { __configLoadError: `${projectPath}: ${e.message}` };
+  if (logLevel) {
+    out.logging = { level: logLevel };
   }
-}
 
-const external = loadExternalConfig();
-export const config = merge(baseConfig, external);
+  if (httpEnabled !== undefined || httpPort !== undefined) {
+    out.http = {};
+    if (httpEnabled !== undefined) out.http.enabled = httpEnabled;
+    if (httpPort !== undefined) out.http.port = httpPort;
+  }
 
-const normalizeUnityConfig = () => {
-  const unityConfig = config.unity || (config.unity = {});
+  if (telemetryEnabled !== undefined) {
+    out.telemetry = { enabled: telemetryEnabled };
+  }
 
-  // Legacy aliases coming from config files
-  const legacyHost = unityConfig.host;
-  const legacyClientHost = unityConfig.clientHost;
-  const legacyBindHost = unityConfig.bindHost;
+  if (lspRequestTimeoutMs !== undefined) {
+    out.lsp = { requestTimeoutMs: lspRequestTimeoutMs };
+  }
 
-  if (!unityConfig.unityHost) {
-    unityConfig.unityHost = legacyBindHost || legacyHost || 'localhost';
+  return out;
+}
+
+function validateAndNormalizeConfig(cfg) {
+  // Unity port
+  if (!Number.isInteger(cfg.unity.port) || cfg.unity.port <= 0 || cfg.unity.port >= 65536) {
+    console.error(
+      `[unity-mcp-server] WARN: Invalid UNITY_MCP_PORT (${cfg.unity.port}); using default 6400`
+    );
+    cfg.unity.port = 6400;
   }
 
-  if (!unityConfig.mcpHost) {
-    unityConfig.mcpHost = legacyClientHost || legacyHost || unityConfig.unityHost;
+  // HTTP port
+  if (cfg.http?.port !== undefined) {
+    if (!Number.isInteger(cfg.http.port) || cfg.http.port <= 0 || cfg.http.port >= 65536) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_HTTP_PORT (${cfg.http.port}); using default 6401`
+      );
+      cfg.http.port = 6401;
+    }
   }
 
-  // Keep bindHost for backwards compatibility with legacy code paths
-  if (!unityConfig.bindHost) {
-    unityConfig.bindHost = legacyBindHost || unityConfig.unityHost;
+  // logging.level
+  if (cfg.logging?.level) {
+    const level = String(cfg.logging.level).toLowerCase();
+    const allowed = new Set(['debug', 'info', 'warn', 'warning', 'error']);
+    if (!allowed.has(level)) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_LOG_LEVEL (${cfg.logging.level}); using default info`
+      );
+      cfg.logging.level = 'info';
+    } else {
+      cfg.logging.level = level === 'warning' ? 'warn' : level;
+    }
   }
 
-  // Maintain legacy properties so older handlers keep working
-  unityConfig.host = unityConfig.unityHost;
-  unityConfig.clientHost = unityConfig.mcpHost;
-};
+  // unity hosts
+  if (typeof cfg.unity.unityHost !== 'string' || cfg.unity.unityHost.trim() === '') {
+    cfg.unity.unityHost = 'localhost';
+  }
+  if (typeof cfg.unity.mcpHost !== 'string' || cfg.unity.mcpHost.trim() === '') {
+    cfg.unity.mcpHost = cfg.unity.unityHost;
+  }
+  cfg.unity.bindHost = cfg.unity.unityHost;
 
-normalizeUnityConfig();
+  // project roots (keep as-is; resolved later)
+  if (cfg.project?.root && typeof cfg.project.root !== 'string') {
+    cfg.project.root = null;
+  }
+  if (cfg.project?.codeIndexRoot && typeof cfg.project.codeIndexRoot !== 'string') {
+    cfg.project.codeIndexRoot = null;
+  }
 
-// Workspace root detection: directory that contains .unity/config.json used
-const initialCwd = process.cwd();
-let workspaceRoot = initialCwd;
-try {
-  if (config.__configPath) {
-    const cfgDir = path.dirname(config.__configPath); // <workspace>/.unity
-    workspaceRoot = path.dirname(cfgDir); // <workspace>
+  // lsp timeout sanity
+  if (cfg.lsp?.requestTimeoutMs !== undefined) {
+    const t = Number(cfg.lsp.requestTimeoutMs);
+    if (!Number.isFinite(t) || t <= 0) {
+      console.error(
+        `[unity-mcp-server] WARN: Invalid UNITY_MCP_LSP_REQUEST_TIMEOUT_MS (${cfg.lsp.requestTimeoutMs}); using default 60000`
+      );
+      cfg.lsp.requestTimeoutMs = 60000;
+    }
   }
-} catch {}
-export const WORKSPACE_ROOT = workspaceRoot;
+}
+
+export const config = merge(baseConfig, loadEnvConfig());
+validateAndNormalizeConfig(config);
+
+// Workspace root: current working directory (used for cache/capture roots)
+export const WORKSPACE_ROOT = process.cwd();
 
 /**
  * Logger utility
@@ -224,18 +292,9 @@ export const WORKSPACE_ROOT = workspaceRoot;
  */
 export const logger = new MCPLogger(config);
 
-// Late log if external config failed to load
-if (config.__configLoadError) {
-  console.error(
-    `${baseConfig.logging.prefix} WARN: Failed to load external config: ${config.__configLoadError}`
-  );
-  delete config.__configLoadError;
-}
-
 // Startup debug log: output config info to stderr for troubleshooting
 // This helps diagnose connection issues (especially in WSL2/Docker environments)
 console.error(`[unity-mcp-server] Startup config:`);
-console.error(`[unity-mcp-server]   Config file: ${config.__configPath || '(not found)'}`);
 console.error(
   `[unity-mcp-server]   Unity host: ${config.unity.mcpHost || config.unity.unityHost || 'localhost'}`
 );

package/src/core/projectInfo.js

@@ -46,7 +46,7 @@ export class ProjectInfoProvider {
 
   async get() {
     if (this.cached) return this.cached;
-    // Env-driven project root override (primarily for tests)
+    // Env-driven project root override (explicit, deterministic)
     const envRootRaw = process.env.UNITY_PROJECT_ROOT;
     if (typeof envRootRaw === 'string' && envRootRaw.trim().length > 0) {
       const envRoot = envRootRaw.trim();
@@ -62,7 +62,7 @@ export class ProjectInfoProvider {
       return this.cached;
     }
 
-    // Config-driven project root (no env fallback)
+    // Config-driven project root (env is mapped into config.project.root)
     const cfgRootRaw = config?.project?.root;
     if (typeof cfgRootRaw === 'string' && cfgRootRaw.trim().length > 0) {
       const cfgRoot = cfgRootRaw.trim();
@@ -122,13 +122,8 @@ export class ProjectInfoProvider {
       return this.cached;
     }
 
-    if (typeof cfgRootRaw === 'string') {
-      throw new Error(
-        'project.root is configured but empty. Set a valid path in .unity/config.json.'
-      );
-    }
     throw new Error(
-      'Unable to resolve Unity project root. Start the server inside a Unity project (directory containing Assets/ and Packages/) or configure project.root in .unity/config.json.'
+      'Unable to resolve Unity project root. Start the server inside a Unity project (directory containing Assets/ and Packages/) or set UNITY_PROJECT_ROOT.'
     );
   }
 

package/src/core/server.js

@@ -91,6 +91,12 @@ async function ensureInitialized() {
 // Initialize server
 export async function startServer(options = {}) {
   try {
+    // MCP stdio transport requires stdout to stay clean (JSON-RPC only).
+    // Guard against accidental console.log usage breaking the protocol.
+    if (options.stdioEnabled !== false && process.env.UNITY_MCP_ALLOW_STDOUT !== '1') {
+      console.log = (...args) => console.error(...args);
+    }
+
     // Step 1: Load minimal config for server metadata
     // (config import is lightweight; avoid importing the MCP TS SDK on startup)
     const { config: serverConfig, logger: serverLogger } = await import('./config.js');

package/src/core/unityConnection.js

@@ -22,6 +22,7 @@ export class UnityConnection extends EventEmitter {
     this.inFlight = 0;
     this.maxInFlight = 1; // process one command at a time by default
     this.connectedAt = null; // Timestamp when connection was established
+    this.hasConnectedOnce = false;
   }
 
   /**
@@ -86,6 +87,7 @@ export class UnityConnection extends EventEmitter {
         this.connected = true;
         this.reconnectAttempts = 0;
         this.connectPromise = null;
+        this.hasConnectedOnce = true;
         this.emit('connected');
         this._pumpQueue(); // flush any queued commands that arrived during reconnect
         settle(resolve);
@@ -120,7 +122,7 @@ export class UnityConnection extends EventEmitter {
           // Destroy the socket to clean up properly
           this.socket.destroy();
           this.isDisconnecting = false;
-          reject(error);
+          reject(wrapUnityConnectError(error, targetHost, config.unity.port));
         } else if (this.connected) {
           // Force close to trigger reconnect logic
           try {
@@ -175,9 +177,11 @@ export class UnityConnection extends EventEmitter {
           this.socket.removeAllListeners();
           this.socket.destroy();
           this.connectPromise = null;
-          settle(reject, new Error('Connection timeout'));
+          const timeoutError = new Error('Connection timeout');
+          timeoutError.code = 'ETIMEDOUT';
+          settle(reject, wrapUnityConnectError(timeoutError, targetHost, config.unity.port));
         }
-      }, config.unity.commandTimeout);
+      }, config.unity.connectTimeout ?? config.unity.commandTimeout);
     });
     return this.connectPromise;
   }
@@ -361,7 +365,7 @@ export class UnityConnection extends EventEmitter {
     if (!this.connected) {
       logger.warning('[Unity] Not connected; waiting for reconnection before sending command');
       await this.ensureConnected({
-        timeoutMs: config.unity.commandTimeout
+        timeoutMs: config.unity.connectTimeout ?? config.unity.commandTimeout
       });
     }
 
@@ -518,6 +522,13 @@ export class UnityConnection extends EventEmitter {
         if (/test environment/i.test(msg)) {
           throw error;
         }
+        if (
+          !this.hasConnectedOnce &&
+          (error?.code === 'UNITY_CONNECTION_REFUSED' || error?.code === 'ECONNREFUSED')
+        ) {
+          // Fail fast for the initial connection when Unity isn't listening.
+          throw error;
+        }
       }
 
       if (this.connected) return;
@@ -525,8 +536,9 @@ export class UnityConnection extends EventEmitter {
     }
 
     if (!this.connected) {
+      const targetHost = config.unity.mcpHost || config.unity.unityHost || 'localhost';
       const error = new Error(
-        `Failed to reconnect to Unity within ${timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`
+        `Failed to connect to Unity at ${targetHost}:${config.unity.port} within ${timeoutMs}ms${lastError ? `: ${lastError.message}` : ''}`
       );
       error.code = 'UNITY_RECONNECT_TIMEOUT';
       throw error;
@@ -545,3 +557,33 @@ export class UnityConnection extends EventEmitter {
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, Math.max(0, ms || 0)));
 }
+
+function wrapUnityConnectError(error, host, port) {
+  const code = error?.code || '';
+  if (code === 'ECONNREFUSED') {
+    const hint = buildUnityConnectionHint(host, port);
+    const wrapped = new Error(
+      `Unity TCP connection refused (ECONNREFUSED) at ${host}:${port}. ${hint}`
+    );
+    wrapped.code = 'UNITY_CONNECTION_REFUSED';
+    wrapped.cause = error;
+    return wrapped;
+  }
+  if (code === 'ETIMEDOUT') {
+    const hint = buildUnityConnectionHint(host, port);
+    const wrapped = new Error(`Unity TCP Connection timeout at ${host}:${port}. ${hint}`);
+    wrapped.code = 'UNITY_CONNECTION_TIMEOUT';
+    wrapped.cause = error;
+    return wrapped;
+  }
+  return error;
+}
+
+function buildUnityConnectionHint(_host, _port) {
+  const configPath = config.__configPath || '.unity/config.json';
+  return (
+    `Start Unity Editor and ensure the Unity MCP package is running (TCP listener). ` +
+    `Check ${configPath} (unity.mcpHost/unity.port). ` +
+    `If using WSL2/Docker → Windows Unity, set unity.mcpHost=host.docker.internal.`
+  );
+}

package/src/handlers/script/ScriptRefsFindToolHandler.js

@@ -213,42 +213,48 @@ export class ScriptRefsFindToolHandler extends BaseToolHandler {
       }
     }
 
-    // Phase 3.2: Build pathTable for deduplication (62% size reduction)
-    const pathSet = new Set();
-    for (const [p] of perFile) {
-      pathSet.add(p);
-    }
-    const pathTable = [...pathSet];
-    const pathIndex = new Map(pathTable.map((p, i) => [p, i]));
-
-    // Pagination and byte limits with compact format
+    // Phase 3.3: Grouped output format (more compact, LLM-friendly)
+    // Pagination and byte limits with grouped format
     const results = [];
     let bytes = 0;
+    let total = 0;
+    let truncated = false;
+
     for (const [filePath, arr] of perFile) {
-      const fileId = pathIndex.get(filePath);
+      const references = [];
       for (const it of arr) {
-        // Compact format: fileId reference + only essential fields
-        const compact = {
-          fileId,
+        const ref = {
           line: it.line,
           column: it.column,
           snippet: it.snippet
         };
-        const json = JSON.stringify(compact);
-        const size = Buffer.byteLength(json, 'utf8');
-        if (results.length >= pageSize || bytes + size > maxBytes) {
-          return { success: true, pathTable, results, total: results.length, truncated: true };
+        const refJson = JSON.stringify(ref);
+        const refSize = Buffer.byteLength(refJson, 'utf8');
+
+        // Check limits before adding
+        if (total >= pageSize || bytes + refSize > maxBytes) {
+          truncated = true;
+          break;
         }
-        results.push(compact);
-        bytes += size;
+        references.push(ref);
+        bytes += refSize;
+        total++;
       }
+
+      if (references.length > 0) {
+        results.push({ path: filePath, references });
+      }
+
+      if (truncated) break;
     }
 
     // Edge case: extreme limits
     const extremeLimits = pageSize <= 1 || maxBytes <= 1;
-    const truncated = extremeLimits && results.length === 0 ? true : false;
+    if (extremeLimits && results.length === 0) {
+      truncated = true;
+    }
 
-    return { success: true, pathTable, results, total: results.length, truncated };
+    return { success: true, results, total, truncated };
   }
 }
 

package/src/handlers/script/ScriptSearchToolHandler.js

@@ -161,9 +161,8 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
       }
       const matcher = buildMatcher(patternType, pattern, flags);
 
+      // Phase 3.3: Grouped output format (more compact, LLM-friendly)
       const results = [];
-      const pathTable = [];
-      const pathId = new Map();
       let bytes = 0;
       let afterFound = !startAfter;
 
@@ -200,13 +199,8 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
         }
         if (matches === 0) continue;
 
-        const id = pathId.has(rel)
-          ? pathId.get(rel)
-          : (pathTable.push(rel) - 1, pathTable.length - 1);
-        pathId.set(rel, id);
-
         const lineRanges = toRanges(matchedLines);
-        const item = { fileId: id, lineRanges };
+        const item = { path: rel, lineRanges };
 
         if (normalizedReturnMode === 'snippets') {
           // Build minimal snippets around first few matches
@@ -229,10 +223,9 @@ export class ScriptSearchToolHandler extends BaseToolHandler {
       return {
         success: true,
         total: results.length,
-        pathTable,
         results,
         cursor:
-          results.length && results.length >= pageSize ? pathTable[pathTable.length - 1] : null
+          results.length && results.length >= pageSize ? results[results.length - 1].path : null
       };
     } catch (e) {
       logger.error(`[script_search] failed: ${e.message}`);

package/src/handlers/script/ScriptSymbolFindToolHandler.js

@@ -22,7 +22,7 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
             type: 'string',
             enum: ['assets', 'packages', 'embedded', 'all'],
             description:
-              'Search scope: assets (Assets/), packages (Packages/), embedded, or all (default: all).'
+              'Search scope: assets (Assets/), packages (Packages/), embedded, or all (default: assets).'
           },
           exact: {
             type: 'boolean',
@@ -110,18 +110,15 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
       filteredRows = filteredRows.filter(r => r.name === target);
     }
 
-    // Phase 3.1: Optimized output format with pathTable (60% size reduction)
-    // Build pathTable for deduplication
-    const pathSet = new Set();
+    // Phase 3.2: Grouped output format (40% more compact than pathTable)
+    // Group symbols by file path
+    const grouped = new Map();
+    let total = 0;
     for (const r of filteredRows) {
-      pathSet.add((r.path || '').replace(/\\/g, '/'));
-    }
-    const pathTable = [...pathSet];
-    const pathIndex = new Map(pathTable.map((p, i) => [p, i]));
-
-    // Build compact results with fileId reference
-    const results = filteredRows.map(r => {
       const p = (r.path || '').replace(/\\/g, '/');
+      if (!grouped.has(p)) {
+        grouped.set(p, []);
+      }
       const symbol = {
         name: r.name,
         kind: r.kind,
@@ -131,10 +128,16 @@ export class ScriptSymbolFindToolHandler extends BaseToolHandler {
       // Only include non-null optional fields
       if (r.ns) symbol.namespace = r.ns;
       if (r.container) symbol.container = r.container;
+      grouped.get(p).push(symbol);
+      total++;
+    }
 
-      return { fileId: pathIndex.get(p), symbol };
-    });
+    // Convert to array format
+    const results = [];
+    for (const [path, symbols] of grouped) {
+      results.push({ path, symbols });
+    }
 
-    return { success: true, pathTable, results, total: results.length };
+    return { success: true, results, total };
   }
 }

package/src/tools/analysis/getComponentValues.js

@@ -106,14 +106,10 @@ export async function getComponentValuesHandler(unityConnection, args) {
       };
     }
 
-    // Success response - result is already the unwrapped data
-    console.log('[DEBUG] GetComponentValues - Full result:', JSON.stringify(result, null, 2));
-
     let responseText = result.summary || `Component values retrieved`;
 
     // Add detailed property information if available
     if (result.properties && Object.keys(result.properties).length > 0) {
-      console.log('[DEBUG] Properties found:', Object.keys(result.properties).length);
       responseText += '\n\nProperties:';
       for (const [key, value] of Object.entries(result.properties)) {
         if (value && typeof value === 'object') {
@@ -144,9 +140,6 @@ export async function getComponentValuesHandler(unityConnection, args) {
           }
         }
       }
-    } else {
-      console.log('[DEBUG] No properties found in result');
-      console.log('[DEBUG] Result keys:', Object.keys(result));
     }
 
     // Add debug information if available