unreal-engine-mcp-server 0.5.1 → 0.5.2

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

@@ -20,7 +20,17 @@ function markSequenceDeleted(path) {
     if (!norm)
         return;
     managedSequences.delete(norm);
-    deletedSequences.add(norm);
+    deletedSequences.delete(norm);
+}
+function getErrorString(res) {
+    if (!res)
+        return '';
+    return typeof res.error === 'string' ? res.error : '';
+}
+function getMessageString(res) {
+    if (!res)
+        return '';
+    return typeof res.message === 'string' ? res.message : '';
 }
 export async function handleSequenceTools(action, args, tools) {
     const seqAction = String(action || '').trim();
@@ -39,8 +49,8 @@ export async function handleSequenceTools(action, args, tools) {
             if (sequencePath && res && res.success !== false) {
                 markSequenceCreated(sequencePath);
             }
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (res && res.success === false && (errorCode === 'FACTORY_NOT_AVAILABLE' || msgLower.includes('ulevelsequencefactorynew not available'))) {
                 const path = sequencePath || (typeof args.path === 'string' ? args.path : undefined);
                 return cleanObject({
@@ -75,8 +85,8 @@ export async function handleSequenceTools(action, args, tools) {
                 subAction: 'add_actor'
             };
             const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (res && res.success === false && path) {
                 const isInvalidSequence = errorCode === 'INVALID_SEQUENCE' || msgLower.includes('sequence_add_actor requires a sequence path') || msgLower.includes('sequence not found');
                 if (isInvalidSequence) {
@@ -114,8 +124,8 @@ export async function handleSequenceTools(action, args, tools) {
         case 'add_actors': {
             const actorNames = Array.isArray(args.actorNames) ? args.actorNames : [];
             const res = await tools.sequenceTools.addActors({ actorNames, path: args.path });
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (actorNames.length === 0 && res && res.success === false && errorCode === 'INVALID_ARGUMENT') {
                 return cleanObject({
                     success: false,
@@ -172,8 +182,8 @@ export async function handleSequenceTools(action, args, tools) {
                 payload.value = { scale: args.value };
             }
             const res = await executeAutomationRequest(tools, 'manage_sequence', payload);
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (errorCode === 'INVALID_ARGUMENT' || msgLower.includes('frame number is required')) {
                 return cleanObject(res);
             }
@@ -237,7 +247,7 @@ export async function handleSequenceTools(action, args, tools) {
                 throw new Error('Invalid speed: must be a positive number');
             }
             let res = await tools.sequenceTools.setPlaybackSpeed({ speed, path: args.path });
-            const errorCode = String((res && res.error) || '').toUpperCase();
+            const errorCode = getErrorString(res).toUpperCase();
             if ((!res || res.success === false) && errorCode === 'EDITOR_NOT_OPEN' && args.path) {
                 await tools.sequenceTools.open({ path: args.path });
                 await new Promise(resolve => setTimeout(resolve, 1000));
@@ -252,7 +262,8 @@ export async function handleSequenceTools(action, args, tools) {
         case 'duplicate': {
             const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
             const destDir = requireNonEmptyString(args.destinationPath, 'destinationPath', 'Missing required parameter: destinationPath');
-            const newName = requireNonEmptyString(args.newName || path.split('/').pop(), 'newName', 'Missing required parameter: newName');
+            const defaultNewName = path.split('/').pop() || '';
+            const newName = requireNonEmptyString(args.newName || defaultNewName, 'newName', 'Missing required parameter: newName');
             const baseDir = destDir.replace(/\/$/, '');
             const destPath = `${baseDir}/${newName}`;
             const res = await tools.sequenceTools.duplicate({ path, destinationPath: destPath });
@@ -262,8 +273,8 @@ export async function handleSequenceTools(action, args, tools) {
             const path = requireNonEmptyString(args.path, 'path', 'Missing required parameter: path');
             const newName = requireNonEmptyString(args.newName, 'newName', 'Missing required parameter: newName');
             const res = await tools.sequenceTools.rename({ path, newName });
-            const errorCode = String((res && res.error) || '').toUpperCase();
-            const msgLower = String((res && res.message) || '').toLowerCase();
+            const errorCode = getErrorString(res).toUpperCase();
+            const msgLower = getMessageString(res).toLowerCase();
             if (res && res.success === false && (errorCode === 'OPERATION_FAILED' || msgLower.includes('failed to rename sequence'))) {
                 return cleanObject({
                     success: false,

package/dist/tools/introspection.d.ts

@@ -31,7 +31,7 @@ export interface PropertyInfo {
     type: string;
     value?: any;
     flags?: string[];
-    metadata?: Record<string, any>;
+    metadata?: Record<string, unknown>;
     category?: string;
     tooltip?: string;
     description?: string;

package/dist/tools/introspection.js

@@ -339,7 +339,7 @@ export class IntrospectionTools {
                 return res;
             }
             catch (err) {
-                const errorMsg = err?.message || String(err);
+                const errorMsg = (err instanceof Error ? err.message : undefined) || String(err);
                 if (errorMsg.includes('404')) {
                     return { success: false, error: `Property '${params.propertyName}' not found on object '${params.objectPath}'` };
                 }

package/dist/tools/level.js

@@ -24,7 +24,7 @@ export class LevelTools extends BaseTool {
             formatted = sanitizePath(formatted);
         }
         catch (e) {
-            throw new Error(`Security validation failed for level path: ${e.message}`);
+            throw new Error(`Security validation failed for level path: ${e instanceof Error ? e.message : String(e)}`);
         }
         formatted = formatted.replace(/\.umap$/i, '');
         if (formatted.endsWith('/')) {
@@ -261,7 +261,7 @@ export class LevelTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Export failed: ${e.message}` };
+            return { success: false, error: `Export failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
     async importLevel(params) {
@@ -292,7 +292,7 @@ export class LevelTools extends BaseTool {
             };
         }
         catch (e) {
-            return { success: false, error: `Import failed: ${e.message}` };
+            return { success: false, error: `Import failed: ${e instanceof Error ? e.message : String(e)}` };
         }
     }
     async saveLevelAs(params) {

package/dist/tools/lighting.d.ts

@@ -19,8 +19,16 @@ export declare class LightingTools {
         castShadows?: boolean;
         temperature?: number;
         useAsAtmosphereSunLight?: boolean;
-        properties?: Record<string, any>;
-    }): Promise<any>;
+        properties?: Record<string, unknown>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createPointLight(params: {
         name: string;
         location?: [number, number, number];
@@ -34,7 +42,15 @@ export declare class LightingTools {
             yaw: number;
             roll: number;
         };
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createSpotLight(params: {
         name: string;
         location: [number, number, number];
@@ -49,7 +65,15 @@ export declare class LightingTools {
         radius?: number;
         color?: [number, number, number];
         castShadows?: boolean;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createRectLight(params: {
         name: string;
         location: [number, number, number];
@@ -63,7 +87,15 @@ export declare class LightingTools {
         intensity?: number;
         color?: [number, number, number];
         castShadows?: boolean;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createDynamicLight(params: {
         name?: string;
         lightType?: 'Point' | 'Spot' | 'Directional' | 'Rect' | string;
@@ -84,7 +116,15 @@ export declare class LightingTools {
             enabled?: boolean;
             frequency?: number;
         };
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
     createSkyLight(params: {
         name: string;
         sourceType?: 'CapturedScene' | 'SpecifiedCubemap';
@@ -148,7 +188,14 @@ export declare class LightingTools {
         buildOnlySelected?: boolean;
         buildReflectionCaptures?: boolean;
         levelPath?: string;
-    }): Promise<any>;
+    }): Promise<{
+        success: boolean;
+        error: string;
+    } | {
+        success: boolean;
+        message: string;
+        error?: undefined;
+    }>;
     createLightingEnabledLevel(params?: {
         levelName?: string;
         copyActors?: boolean;

package/dist/tools/lighting.js

@@ -128,7 +128,7 @@ export class LightingTools {
             return { success: true, message: `Directional light '${name}' spawned` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create directional light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create directional light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createPointLight(params) {
@@ -202,7 +202,7 @@ export class LightingTools {
             return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create point light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create point light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createSpotLight(params) {
@@ -302,7 +302,7 @@ export class LightingTools {
             return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create spot light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create spot light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createRectLight(params) {
@@ -388,7 +388,7 @@ export class LightingTools {
             return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
         }
         catch (e) {
-            return { success: false, error: `Failed to create rect light: ${e?.message ?? e}` };
+            return { success: false, error: `Failed to create rect light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
         }
     }
     async createDynamicLight(params) {

package/dist/tools/materials.d.ts

@@ -43,7 +43,7 @@ export declare class MaterialTools {
         transport?: undefined;
         warnings?: undefined;
     }>;
-    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>): Promise<any>;
+    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, unknown>): Promise<any>;
     addNode(params: {
         materialPath: string;
         nodeType: string;

package/dist/types/tool-types.d.ts

@@ -3,6 +3,8 @@ export interface BaseToolResponse {
     message?: string;
     error?: string;
     warning?: string;
+    retriable?: boolean;
+    scope?: string;
 }
 export interface AssetInfo {
     Name: string;

package/dist/unreal-bridge.js

@@ -206,7 +206,7 @@ export class UnrealBridge {
             const success = response.success !== false;
             const rawResult = response.result && typeof response.result === 'object'
                 ? { ...response.result }
-                : response.result;
+                : undefined;
             const value = rawResult?.value ??
                 rawResult?.propertyValue ??
                 (success ? rawResult : undefined);
@@ -295,7 +295,7 @@ export class UnrealBridge {
             const success = response.success !== false;
             const rawResult = response.result && typeof response.result === 'object'
                 ? { ...response.result }
-                : response.result;
+                : undefined;
             if (success) {
                 return {
                     success: true,
@@ -423,7 +423,7 @@ export class UnrealBridge {
             const resp = await bridge.sendAutomationRequest('system_control', { action: 'get_engine_version' }, { timeoutMs: 15000 });
             const raw = resp && typeof resp.result === 'object'
                 ? resp.result
-                : (resp?.result ?? resp ?? {});
+                : resp?.result ?? resp ?? {};
             const version = typeof raw.version === 'string' ? raw.version : 'unknown';
             const major = typeof raw.major === 'number' ? raw.major : 0;
             const minor = typeof raw.minor === 'number' ? raw.minor : 0;
@@ -459,7 +459,7 @@ export class UnrealBridge {
             const resp = await bridge.sendAutomationRequest('system_control', { action: 'get_feature_flags' }, { timeoutMs: 15000 });
             const raw = resp && typeof resp.result === 'object'
                 ? resp.result
-                : (resp?.result ?? resp ?? {});
+                : resp?.result ?? resp ?? {};
             const subs = raw && typeof raw.subsystems === 'object'
                 ? raw.subsystems
                 : {};

package/dist/utils/command-validator.js

@@ -1,12 +1,13 @@
 export class CommandValidator {
     static DANGEROUS_COMMANDS = [
-        'quit', 'exit', 'delete', 'destroy', 'kill', 'crash',
+        'quit', 'exit', 'kill', 'crash',
+        'r.gpucrash', 'r.crash', 'debug crash', 'forcecrash', 'debug break',
+        'assert false', 'check(false)',
         'viewmode visualizebuffer basecolor',
         'viewmode visualizebuffer worldnormal',
-        'r.gpucrash',
-        'buildpaths',
-        'rebuildnavigation',
-        'obj garbage', 'obj list', 'memreport'
+        'buildpaths', 'rebuildnavigation',
+        'obj garbage', 'obj list', 'memreport',
+        'delete', 'destroy'
     ];
     static FORBIDDEN_TOKENS = [
         'rm ', 'rm-', 'del ', 'format ', 'shutdown', 'reboot',

package/dist/utils/error-handler.d.ts

@@ -8,8 +8,29 @@ export declare enum ErrorType {
     TIMEOUT = "TIMEOUT",
     UNKNOWN = "UNKNOWN"
 }
+interface ErrorResponseDebug {
+    errorType: ErrorType;
+    originalError: string;
+    stack?: string;
+    context?: Record<string, unknown>;
+    retriable: boolean;
+    scope: string;
+}
+interface ErrorToolResponse extends BaseToolResponse {
+    _debug?: ErrorResponseDebug;
+}
+interface ErrorLike {
+    message?: string;
+    code?: string;
+    type?: string;
+    errorType?: string;
+    stack?: string;
+    response?: {
+        status?: number;
+    };
+}
 export declare class ErrorHandler {
-    static createErrorResponse(error: any, toolName: string, context?: any): BaseToolResponse;
+    static createErrorResponse(error: unknown, toolName: string, context?: Record<string, unknown>): ErrorToolResponse;
     private static categorizeError;
     private static getUserFriendlyMessage;
     private static isRetriable;
@@ -18,7 +39,8 @@ export declare class ErrorHandler {
         initialDelay?: number;
         maxDelay?: number;
         backoffMultiplier?: number;
-        shouldRetry?: (error: any) => boolean;
+        shouldRetry?: (error: ErrorLike | Error | unknown) => boolean;
     }): Promise<T>;
 }
+export {};
 //# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.js

@@ -10,43 +10,75 @@ export var ErrorType;
     ErrorType["TIMEOUT"] = "TIMEOUT";
     ErrorType["UNKNOWN"] = "UNKNOWN";
 })(ErrorType || (ErrorType = {}));
+function normalizeErrorToLike(error) {
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack,
+            code: error.code
+        };
+    }
+    if (typeof error === 'object' && error !== null) {
+        const obj = error;
+        return {
+            message: typeof obj.message === 'string' ? obj.message : undefined,
+            code: typeof obj.code === 'string' ? obj.code : undefined,
+            type: typeof obj.type === 'string' ? obj.type : undefined,
+            errorType: typeof obj.errorType === 'string' ? obj.errorType : undefined,
+            stack: typeof obj.stack === 'string' ? obj.stack : undefined,
+            response: typeof obj.response === 'object' && obj.response !== null
+                ? {
+                    status: typeof obj.response.status === 'number'
+                        ? obj.response.status
+                        : undefined
+                }
+                : undefined
+        };
+    }
+    return { message: String(error) };
+}
 export class ErrorHandler {
     static createErrorResponse(error, toolName, context) {
-        const errorType = this.categorizeError(error);
-        const userMessage = this.getUserFriendlyMessage(errorType, error);
-        const retriable = this.isRetriable(error);
+        const errorObj = normalizeErrorToLike(error);
+        const errorType = this.categorizeError(errorObj);
+        const userMessage = this.getUserFriendlyMessage(errorType, errorObj);
+        const retriable = this.isRetriable(errorObj);
         const scope = context?.scope || `tool-call/${toolName}`;
+        const errorMessage = errorObj.message || String(error);
+        const errorStack = errorObj.stack;
         log.error(`Tool ${toolName} failed:`, {
             type: errorType,
-            message: error.message || error,
+            message: errorMessage,
             retriable,
             scope,
             context
         });
-        return {
+        const response = {
             success: false,
             error: userMessage,
             message: `Failed to execute ${toolName}: ${userMessage}`,
-            retriable: retriable,
-            scope: scope,
-            ...(process.env.NODE_ENV === 'development' && {
-                _debug: {
-                    errorType,
-                    originalError: error.message || String(error),
-                    stack: error.stack,
-                    context,
-                    retriable,
-                    scope
-                }
-            })
+            retriable,
+            scope
         };
+        if (process.env.NODE_ENV === 'development') {
+            response._debug = {
+                errorType,
+                originalError: errorMessage,
+                stack: errorStack,
+                context,
+                retriable,
+                scope
+            };
+        }
+        return response;
     }
     static categorizeError(error) {
-        const explicitType = (error?.type || error?.errorType || '').toString().toUpperCase();
+        const errorObj = typeof error === 'object' ? error : null;
+        const explicitType = (errorObj?.type || errorObj?.errorType || '').toString().toUpperCase();
         if (explicitType && Object.values(ErrorType).includes(explicitType)) {
             return explicitType;
         }
-        const errorMessage = error?.message?.toLowerCase() || String(error).toLowerCase();
+        const errorMessage = (errorObj?.message || String(error)).toLowerCase();
         if (errorMessage.includes('econnrefused') ||
             errorMessage.includes('timeout') ||
             errorMessage.includes('connection') ||
@@ -77,7 +109,9 @@ export class ErrorHandler {
         return ErrorType.UNKNOWN;
     }
     static getUserFriendlyMessage(type, error) {
-        const originalMessage = error.message || String(error);
+        const originalMessage = (typeof error === 'object' && error !== null && 'message' in error)
+            ? error.message || String(error)
+            : String(error);
         switch (type) {
             case ErrorType.CONNECTION:
                 return 'Failed to connect to Unreal Engine. Please ensure the Automation Bridge plugin is active and the editor is running.';
@@ -97,9 +131,10 @@ export class ErrorHandler {
     }
     static isRetriable(error) {
         try {
-            const code = (error?.code || '').toString().toUpperCase();
-            const msg = (error?.message || String(error) || '').toLowerCase();
-            const status = Number((error?.response?.status));
+            const errorObj = typeof error === 'object' ? error : null;
+            const code = (errorObj?.code || '').toString().toUpperCase();
+            const msg = (errorObj?.message || String(error) || '').toLowerCase();
+            const status = Number(errorObj?.response?.status);
             if (['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE'].includes(code))
                 return true;
             if (/timeout|timed out|network|connection|closed|unavailable|busy|temporar/.test(msg))

package/dist/utils/normalize.d.ts

@@ -10,11 +10,14 @@ export interface Rot3Obj {
 }
 export type Vec3Tuple = [number, number, number];
 export type Rot3Tuple = [number, number, number];
-export declare function toVec3Object(input: any): Vec3Obj | null;
-export declare function toRotObject(input: any): Rot3Obj | null;
-export declare function toVec3Tuple(input: any): Vec3Tuple | null;
-export declare function toRotTuple(input: any): Rot3Tuple | null;
+type VectorInput = Vec3Obj | Vec3Tuple | Record<string, unknown> | unknown[];
+type RotationInput = Rot3Obj | Rot3Tuple | Record<string, unknown> | unknown[];
+export declare function toVec3Object(input: VectorInput | unknown): Vec3Obj | null;
+export declare function toRotObject(input: RotationInput | unknown): Rot3Obj | null;
+export declare function toVec3Tuple(input: VectorInput | unknown): Vec3Tuple | null;
+export declare function toRotTuple(input: RotationInput | unknown): Rot3Tuple | null;
 export declare function toFiniteNumber(raw: unknown): number | undefined;
 export declare function normalizePartialVector(value: any, alternateKeys?: string[]): Record<string, number> | undefined;
 export declare function normalizeTransformInput(transform: any): Record<string, unknown> | undefined;
+export {};
 //# sourceMappingURL=normalize.d.ts.map

package/dist/utils/normalize.js

@@ -3,13 +3,14 @@ export function toVec3Object(input) {
         if (Array.isArray(input) && input.length === 3) {
             const [x, y, z] = input;
             if ([x, y, z].every(v => typeof v === 'number' && isFinite(v))) {
-                return { x, y, z };
+                return { x: x, y: y, z: z };
             }
         }
-        if (input && typeof input === 'object') {
-            const x = Number(input.x ?? input.X);
-            const y = Number(input.y ?? input.Y);
-            const z = Number(input.z ?? input.Z);
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            const obj = input;
+            const x = Number(obj.x ?? obj.X);
+            const y = Number(obj.y ?? obj.Y);
+            const z = Number(obj.z ?? obj.Z);
             if ([x, y, z].every(v => typeof v === 'number' && !isNaN(v) && isFinite(v))) {
                 return { x, y, z };
             }
@@ -23,13 +24,14 @@ export function toRotObject(input) {
         if (Array.isArray(input) && input.length === 3) {
             const [pitch, yaw, roll] = input;
             if ([pitch, yaw, roll].every(v => typeof v === 'number' && isFinite(v))) {
-                return { pitch, yaw, roll };
+                return { pitch: pitch, yaw: yaw, roll: roll };
             }
         }
-        if (input && typeof input === 'object') {
-            const pitch = Number(input.pitch ?? input.Pitch);
-            const yaw = Number(input.yaw ?? input.Yaw);
-            const roll = Number(input.roll ?? input.Roll);
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            const obj = input;
+            const pitch = Number(obj.pitch ?? obj.Pitch);
+            const yaw = Number(obj.yaw ?? obj.Yaw);
+            const roll = Number(obj.roll ?? obj.Roll);
             if ([pitch, yaw, roll].every(v => typeof v === 'number' && !isNaN(v) && isFinite(v))) {
                 return { pitch, yaw, roll };
             }