unreal-engine-mcp-server 0.5.0 → 0.5.2

package/src/tools/handlers/actor-handlers.ts

@@ -1,13 +1,10 @@
-import { cleanObject } from '../../utils/safe-json.js';
 import { ITools } from '../../types/tool-interfaces.js';
 import { executeAutomationRequest } from './common-handlers.js';
-import { Logger } from '../../utils/logger.js';
 import { normalizeArgs } from './argument-helper.js';
+import { ResponseFactory } from '../../utils/response-factory.js';
 
 type ActorActionHandler = (args: any, tools: ITools) => Promise<any>;
 
-const logger = new Logger('ActorHandlers');
-
 const handlers: Record<string, ActorActionHandler> = {
     spawn: async (args, tools) => {
         // Class name aliases for user-friendly names
@@ -35,18 +32,18 @@ const handlers: Record<string, ActorActionHandler> = {
             { key: 'actorName', aliases: ['name'] },
             { key: 'timeoutMs', default: undefined }
         ]);
-        
+
         const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined;
 
         // Extremely small timeouts are treated as an immediate timeout-style
         // failure so tests can exercise timeout handling deterministically
         // without relying on editor performance.
         if (typeof timeoutMs === 'number' && timeoutMs > 0 && timeoutMs < 200) {
-            return cleanObject({
+            return {
                 success: false,
                 error: `Timeout too small for spawn operation: ${timeoutMs}ms`,
                 message: 'Timeout too small for spawn operation'
-            });
+            };
         }
 
         // For SplineActor alias, add SplineComponent automatically
@@ -113,7 +110,6 @@ const handlers: Record<string, ActorActionHandler> = {
                     // Auto-enable physics logic
                     const compsResult = await tools.actorTools.getComponents(params.actorName);
                     if (compsResult && compsResult.success && Array.isArray(compsResult.components)) {
-                        logger.debug('Components found:', JSON.stringify(compsResult.components));
                         const meshComp = compsResult.components.find((c: any) => {
                             const name = c.name || c;
                             const match = typeof name === 'string' && (
@@ -121,13 +117,11 @@ const handlers: Record<string, ActorActionHandler> = {
                                 name.toLowerCase().includes('mesh') ||
                                 name.toLowerCase().includes('primitive')
                             );
-                            logger.debug(`Checking component '${name}' matches? ${match}`);
                             return match;
                         });
 
                         if (meshComp) {
                             const compName = meshComp.name || meshComp;
-                            logger.debug(`Auto-enabling physics for component: ${compName}`); // Debug log
                             await tools.actorTools.setComponentProperties({
                                 actorName: params.actorName,
                                 componentName: compName,
@@ -253,7 +247,7 @@ const handlers: Record<string, ActorActionHandler> = {
         const params = normalizeArgs(args, [
             { key: 'name', aliases: ['actorName', 'query'], required: true }
         ]);
-        
+
         // Use the plugin's fuzzy query endpoint (contains-match) instead of the
         // exact lookup endpoint. This improves "spawn then find" reliability.
         return tools.actorTools.findByName(params.name);
@@ -261,11 +255,16 @@ const handlers: Record<string, ActorActionHandler> = {
 };
 
 export async function handleActorTools(action: string, args: any, tools: ITools) {
-    const handler = handlers[action];
-    if (handler) {
-        const res = await handler(args, tools);
-        return cleanObject(res);
+    try {
+        const handler = handlers[action];
+        if (handler) {
+            const res = await handler(args, tools);
+            return ResponseFactory.success(res);
+        }
+        // Fallback to direct bridge call or error
+        const res = await executeAutomationRequest(tools, 'control_actor', args);
+        return ResponseFactory.success(res);
+    } catch (error) {
+        return ResponseFactory.error(error);
     }
-    // Fallback to direct bridge call or error
-    return executeAutomationRequest(tools, 'control_actor', args);
 }