unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/tools/environment.d.ts

@@ -1,12 +1,7 @@
 import { AutomationBridge } from '../automation/index.js';
 import { UnrealBridge } from '../unreal-bridge.js';
-interface EnvironmentResult {
-    success: boolean;
-    message?: string;
-    error?: string;
-    details?: Record<string, unknown>;
-}
-export declare class EnvironmentTools {
+import { IEnvironmentTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class EnvironmentTools implements IEnvironmentTools {
     private automationBridge?;
     constructor(_bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
     setAutomationBridge(automationBridge?: AutomationBridge): void;
@@ -16,21 +11,20 @@ export declare class EnvironmentTools {
     private getDefaultSkylightIntensity;
     private normalizeNumber;
     private invoke;
-    setTimeOfDay(hour: unknown): Promise<EnvironmentResult>;
-    setSunIntensity(intensity: unknown): Promise<EnvironmentResult>;
-    setSkylightIntensity(intensity: unknown): Promise<EnvironmentResult>;
+    setTimeOfDay(hour: unknown): Promise<StandardActionResponse>;
+    setSunIntensity(intensity: unknown): Promise<StandardActionResponse>;
+    setSkylightIntensity(intensity: unknown): Promise<StandardActionResponse>;
     exportSnapshot(params: {
         path?: unknown;
         filename?: unknown;
-    }): Promise<EnvironmentResult>;
+    }): Promise<StandardActionResponse>;
     importSnapshot(params: {
         path?: unknown;
         filename?: unknown;
-    }): Promise<EnvironmentResult>;
+    }): Promise<StandardActionResponse>;
     cleanup(params?: {
         names?: unknown;
         name?: unknown;
-    }): Promise<EnvironmentResult>;
+    }): Promise<StandardActionResponse>;
 }
-export {};
 //# sourceMappingURL=environment.d.ts.map

package/dist/tools/foliage.d.ts

@@ -1,6 +1,7 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
-export declare class FoliageTools {
+import { IFoliageTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class FoliageTools implements IFoliageTools {
     private bridge;
     private automationBridge?;
     constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
@@ -15,87 +16,21 @@ export declare class FoliageTools {
         alignToNormal?: boolean;
         randomYaw?: boolean;
         groundSlope?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        note?: undefined;
-        created?: undefined;
-        exists?: undefined;
-        method?: undefined;
-        assetPath?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        note: string | undefined;
-        created?: undefined;
-        exists?: undefined;
-        method?: undefined;
-        assetPath?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        created: boolean;
-        exists: boolean;
-        method: string;
-        assetPath: string | undefined;
-        usedMesh: string | undefined;
-        note: string | undefined;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     paintFoliage(params: {
         foliageType: string;
         position: [number, number, number];
         brushSize?: number;
         paintDensity?: number;
         eraseMode?: boolean;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        note?: undefined;
-        added?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        note: string | undefined;
-        added?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        added: number;
-        note: string | undefined;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     getFoliageInstances(params: {
         foliageType?: string;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        count?: undefined;
-        instances?: undefined;
-    } | {
-        success: boolean;
-        count: number;
-        instances: any[];
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     removeFoliage(params: {
         foliageType?: string;
         removeAll?: boolean;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        instancesRemoved?: undefined;
-    } | {
-        success: boolean;
-        instancesRemoved: number;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     createInstancedMesh(params: {
         name: string;
         meshPath: string;
@@ -106,18 +41,12 @@ export declare class FoliageTools {
         }>;
         enableCulling?: boolean;
         cullDistance?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     setFoliageLOD(params: {
         foliageType: string;
         lodDistances?: number[];
         screenSize?: number[];
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     addFoliage(params: {
         foliageType: string;
         locations: Array<{
@@ -125,15 +54,7 @@ export declare class FoliageTools {
             y: number;
             z: number;
         }>;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     createProceduralFoliage(params: {
         name: string;
         bounds?: {
@@ -161,23 +82,7 @@ export declare class FoliageTools {
         size?: [number, number, number];
         seed?: number;
         tileSize?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        details?: undefined;
-        volumeActor?: undefined;
-        spawnerPath?: undefined;
-        foliageTypesCount?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        details: import("../automation/types.js").AutomationBridgeResponseMessage;
-        volumeActor: any;
-        spawnerPath: any;
-        foliageTypesCount: any;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     addFoliageInstances(params: {
         foliageType: string;
         transforms: Array<{
@@ -185,31 +90,13 @@ export declare class FoliageTools {
             rotation?: [number, number, number];
             scale?: [number, number, number];
         }>;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        message: string;
-        instancesCount?: undefined;
-    } | {
-        success: boolean;
-        message: string;
-        instancesCount: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        instancesCount?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     setFoliageCollision(params: {
         foliageType: string;
         collisionEnabled?: boolean;
         collisionProfile?: string;
         generateOverlapEvents?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     createGrassSystem(params: {
         name: string;
         grassTypes: Array<{
@@ -220,46 +107,34 @@ export declare class FoliageTools {
         }>;
         windStrength?: number;
         windSpeed?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     removeFoliageInstances(params: {
         foliageType: string;
         position: [number, number, number];
         radius: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     selectFoliageInstances(params: {
         foliageType: string;
         position?: [number, number, number];
         radius?: number;
         selectAll?: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     updateFoliageInstances(params: {
         foliageType: string;
         updateTransforms?: boolean;
         updateMesh?: boolean;
         newMeshPath?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     createFoliageSpawner(params: {
         name: string;
         spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All';
         excludeAreas?: Array<[number, number, number, number]>;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     optimizeFoliage(params: {
         mergeInstances?: boolean;
         generateClusters?: boolean;
         clusterSize?: number;
         reduceDrawCalls?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=foliage.d.ts.map

package/dist/tools/foliage.js

@@ -161,7 +161,8 @@ export class FoliageTools {
             return {
                 success: true,
                 count: coerceNumber(payload.count) ?? 0,
-                instances: payload.instances ?? []
+                instances: payload.instances ?? [],
+                message: 'Foliage instances retrieved'
             };
         }
         catch (error) {
@@ -184,7 +185,8 @@ export class FoliageTools {
             const payload = response.result;
             return {
                 success: true,
-                instancesRemoved: coerceNumber(payload.instancesRemoved) ?? 0
+                instancesRemoved: coerceNumber(payload.instancesRemoved) ?? 0,
+                message: 'Foliage removed'
             };
         }
         catch (error) {

package/dist/tools/handlers/actor-handlers.d.ts

@@ -1,3 +1,3 @@
 import { ITools } from '../../types/tool-interfaces.js';
-export declare function handleActorTools(action: string, args: any, tools: ITools): Promise<any>;
+export declare function handleActorTools(action: string, args: any, tools: ITools): Promise<import("../../types/tool-interfaces.js").StandardActionResponse<any>>;
 //# sourceMappingURL=actor-handlers.d.ts.map

package/dist/tools/handlers/actor-handlers.js

@@ -1,8 +1,6 @@
-import { cleanObject } from '../../utils/safe-json.js';
 import { executeAutomationRequest } from './common-handlers.js';
-import { Logger } from '../../utils/logger.js';
 import { normalizeArgs } from './argument-helper.js';
-const logger = new Logger('ActorHandlers');
+import { ResponseFactory } from '../../utils/response-factory.js';
 const handlers = {
     spawn: async (args, tools) => {
         const classAliases = {
@@ -30,11 +28,11 @@ const handlers = {
         ]);
         const timeoutMs = typeof params.timeoutMs === 'number' ? params.timeoutMs : undefined;
         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'
-            });
+            };
         }
         const originalClass = args.classPath || args.class || args.type || args.actorClass;
         const componentToAdd = (originalClass === 'SplineActor' || originalClass === 'Spline')
@@ -87,18 +85,15 @@ const handlers = {
                 try {
                     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) => {
                             const name = c.name || c;
                             const match = typeof name === 'string' && (name.toLowerCase().includes('staticmesh') ||
                                 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}`);
                             await tools.actorTools.setComponentProperties({
                                 actorName: params.actorName,
                                 componentName: compName,
@@ -222,11 +217,17 @@ const handlers = {
     }
 };
 export async function handleActorTools(action, args, tools) {
-    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);
+        }
+        const res = await executeAutomationRequest(tools, 'control_actor', args);
+        return ResponseFactory.success(res);
+    }
+    catch (error) {
+        return ResponseFactory.error(error);
     }
-    return executeAutomationRequest(tools, 'control_actor', args);
 }
 //# sourceMappingURL=actor-handlers.js.map