unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/utils/errors.js

@@ -1,256 +0,0 @@
-/**
- * Enhanced error types for better error handling and recovery
- */
-export var ErrorCode;
-(function (ErrorCode) {
-    // Connection errors
-    ErrorCode["CONNECTION_FAILED"] = "CONNECTION_FAILED";
-    ErrorCode["CONNECTION_TIMEOUT"] = "CONNECTION_TIMEOUT";
-    ErrorCode["CONNECTION_REFUSED"] = "CONNECTION_REFUSED";
-    // API errors
-    ErrorCode["API_ERROR"] = "API_ERROR";
-    ErrorCode["INVALID_RESPONSE"] = "INVALID_RESPONSE";
-    ErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
-    // Validation errors
-    ErrorCode["VALIDATION_ERROR"] = "VALIDATION_ERROR";
-    ErrorCode["INVALID_PARAMETERS"] = "INVALID_PARAMETERS";
-    ErrorCode["MISSING_REQUIRED_FIELD"] = "MISSING_REQUIRED_FIELD";
-    // Resource errors
-    ErrorCode["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
-    ErrorCode["RESOURCE_LOCKED"] = "RESOURCE_LOCKED";
-    ErrorCode["RESOURCE_UNAVAILABLE"] = "RESOURCE_UNAVAILABLE";
-    // Permission errors
-    ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
-    ErrorCode["FORBIDDEN"] = "FORBIDDEN";
-    // System errors
-    ErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
-    ErrorCode["CIRCUIT_BREAKER_OPEN"] = "CIRCUIT_BREAKER_OPEN";
-    ErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
-})(ErrorCode || (ErrorCode = {}));
-/**
- * Base application error with metadata
- */
-export class AppError extends Error {
-    metadata;
-    constructor(message, metadata = {}) {
-        super(message);
-        this.name = this.constructor.name;
-        this.metadata = {
-            code: metadata.code || ErrorCode.INTERNAL_ERROR,
-            retriable: metadata.retriable || false,
-            timestamp: new Date(),
-            ...metadata
-        };
-        Error.captureStackTrace(this, this.constructor);
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            ...this.metadata,
-            stack: this.stack
-        };
-    }
-}
-/**
- * Connection-related errors
- */
-export class ConnectionError extends AppError {
-    constructor(message, metadata = {}) {
-        super(message, {
-            code: ErrorCode.CONNECTION_FAILED,
-            retriable: true,
-            statusCode: 503,
-            ...metadata
-        });
-    }
-}
-/**
- * API-related errors
- */
-export class ApiError extends AppError {
-    constructor(message, statusCode, metadata = {}) {
-        super(message, {
-            code: ErrorCode.API_ERROR,
-            statusCode,
-            retriable: statusCode >= 500 || statusCode === 429,
-            ...metadata
-        });
-    }
-}
-/**
- * Validation errors
- */
-export class ValidationError extends AppError {
-    constructor(message, metadata = {}) {
-        super(message, {
-            code: ErrorCode.VALIDATION_ERROR,
-            statusCode: 400,
-            retriable: false,
-            ...metadata
-        });
-    }
-}
-/**
- * Resource errors
- */
-export class ResourceError extends AppError {
-    constructor(message, code, metadata = {}) {
-        super(message, {
-            code,
-            statusCode: code === ErrorCode.RESOURCE_NOT_FOUND ? 404 : 409,
-            retriable: code === ErrorCode.RESOURCE_LOCKED,
-            ...metadata
-        });
-    }
-}
-/**
- * Circuit Breaker implementation for fault tolerance
- */
-export var CircuitState;
-(function (CircuitState) {
-    CircuitState["CLOSED"] = "CLOSED";
-    CircuitState["OPEN"] = "OPEN";
-    CircuitState["HALF_OPEN"] = "HALF_OPEN";
-})(CircuitState || (CircuitState = {}));
-export class CircuitBreaker {
-    state = CircuitState.CLOSED;
-    failures = 0;
-    successCount = 0;
-    lastFailureTime;
-    options;
-    constructor(options = {}) {
-        this.options = {
-            threshold: options.threshold || 5,
-            timeout: options.timeout || 60000, // 1 minute
-            resetTimeout: options.resetTimeout || 30000, // 30 seconds
-            onStateChange: options.onStateChange
-        };
-    }
-    /**
-     * Execute function with circuit breaker protection
-     */
-    async execute(fn) {
-        // Check circuit state
-        if (this.state === CircuitState.OPEN) {
-            if (this.shouldAttemptReset()) {
-                this.transitionTo(CircuitState.HALF_OPEN);
-            }
-            else {
-                throw new AppError('Circuit breaker is open', {
-                    code: ErrorCode.CIRCUIT_BREAKER_OPEN,
-                    retriable: true,
-                    context: {
-                        failures: this.failures,
-                        lastFailure: this.lastFailureTime
-                    }
-                });
-            }
-        }
-        try {
-            const result = await fn();
-            this.onSuccess();
-            return result;
-        }
-        catch (error) {
-            this.onFailure();
-            throw error;
-        }
-    }
-    onSuccess() {
-        this.failures = 0;
-        if (this.state === CircuitState.HALF_OPEN) {
-            this.successCount++;
-            if (this.successCount >= 3) {
-                this.transitionTo(CircuitState.CLOSED);
-            }
-        }
-    }
-    onFailure() {
-        this.failures++;
-        this.lastFailureTime = new Date();
-        this.successCount = 0;
-        if (this.failures >= this.options.threshold) {
-            this.transitionTo(CircuitState.OPEN);
-        }
-    }
-    shouldAttemptReset() {
-        return (this.lastFailureTime !== undefined &&
-            Date.now() - this.lastFailureTime.getTime() >= this.options.resetTimeout);
-    }
-    transitionTo(newState) {
-        const oldState = this.state;
-        this.state = newState;
-        if (newState === CircuitState.CLOSED) {
-            this.failures = 0;
-            this.successCount = 0;
-        }
-        if (this.options.onStateChange && oldState !== newState) {
-            this.options.onStateChange(oldState, newState);
-        }
-    }
-    getState() {
-        return this.state;
-    }
-    getMetrics() {
-        return {
-            state: this.state,
-            failures: this.failures,
-            successCount: this.successCount,
-            lastFailureTime: this.lastFailureTime
-        };
-    }
-}
-/**
- * Error recovery strategies
- */
-export class ErrorRecovery {
-    static circuitBreakers = new Map();
-    /**
-     * Get or create circuit breaker for a service
-     */
-    static getCircuitBreaker(service, options) {
-        if (!this.circuitBreakers.has(service)) {
-            this.circuitBreakers.set(service, new CircuitBreaker(options));
-        }
-        const breaker = this.circuitBreakers.get(service);
-        if (!breaker) {
-            throw new Error(`Circuit breaker for service ${service} could not be created`);
-        }
-        return breaker;
-    }
-    /**
-     * Wrap function with error recovery
-     */
-    static async withRecovery(fn, options) {
-        const breaker = this.getCircuitBreaker(options.service);
-        try {
-            return await breaker.execute(fn);
-        }
-        catch (error) {
-            if (options.onError) {
-                options.onError(error);
-            }
-            // Try fallback if available
-            if (options.fallback) {
-                return await options.fallback();
-            }
-            throw error;
-        }
-    }
-    /**
-     * Check if error is retriable
-     */
-    static isRetriable(error) {
-        if (error instanceof AppError) {
-            return error.metadata.retriable;
-        }
-        // Check for network errors
-        const message = error.message.toLowerCase();
-        return (message.includes('timeout') ||
-            message.includes('network') ||
-            message.includes('econnrefused') ||
-            message.includes('econnreset'));
-    }
-}
-//# sourceMappingURL=errors.js.map

package/src/python/editor_compat.py

@@ -1,181 +0,0 @@
-"""
-Compatibility module for handling deprecated Unreal Engine Python API calls.
-Provides wrapper functions that use the newer recommended APIs where available.
-"""
-
-import unreal
-
-def get_editor_world():
-    """
-    Get the current editor world using the recommended API.
-    """
-    try:
-        # Use new recommended API
-        if hasattr(unreal, 'UnrealEditorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-            if hasattr(subsystem, 'get_editor_world'):
-                return subsystem.get_editor_world()
-    except:
-        pass
-    
-    return None
-
-def get_all_level_actors():
-    """
-    Get all actors in the current level using the recommended API.
-    """
-    try:
-        # Use new recommended API - EditorActorSubsystem
-        if hasattr(unreal, 'EditorActorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-            if hasattr(subsystem, 'get_all_level_actors'):
-                return subsystem.get_all_level_actors()
-    except:
-        pass
-    
-    return []
-
-def spawn_actor_from_class(actor_class, location, rotation):
-    """
-    Spawn an actor in the level using the recommended API.
-    """
-    try:
-        # Use new recommended API
-        if hasattr(unreal, 'EditorActorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-            if hasattr(subsystem, 'spawn_actor_from_class'):
-                return subsystem.spawn_actor_from_class(actor_class, location, rotation)
-    except:
-        pass
-    
-    return None
-
-def destroy_actor(actor):
-    """
-    Destroy an actor in the level using the recommended API.
-    """
-    try:
-        # Use new recommended API
-        if hasattr(unreal, 'EditorActorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-            if hasattr(subsystem, 'destroy_actor'):
-                return subsystem.destroy_actor(actor)
-    except:
-        pass
-    
-    return False
-
-def save_current_level():
-    """
-    Save the current level using the recommended API.
-    """
-    try:
-        # Use new recommended API - LevelEditorSubsystem
-        if hasattr(unreal, 'LevelEditorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.LevelEditorSubsystem)
-            if hasattr(subsystem, 'save_current_level'):
-                return subsystem.save_current_level()
-    except:
-        pass
-    
-    return False
-
-def get_level_viewport_camera_info():
-    """
-    Get level viewport camera information using the recommended API.
-    """
-    try:
-        # Use new recommended API
-        if hasattr(unreal, 'UnrealEditorSubsystem'):
-            subsystem = unreal.get_editor_subsystem(unreal.UnrealEditorSubsystem)
-            if hasattr(subsystem, 'get_level_viewport_camera_info'):
-                return subsystem.get_level_viewport_camera_info()
-    except:
-        pass
-    
-    return None
-
-# Blueprint compatibility functions
-def get_blueprint_generated_class(blueprint):
-    """
-    Get the generated class from a blueprint using the recommended API.
-    """
-    try:
-        # Try using BlueprintEditorLibrary
-        if hasattr(unreal, 'BlueprintEditorLibrary'):
-            return unreal.BlueprintEditorLibrary.generated_class(blueprint)
-    except:
-        pass
-    
-    # Try getting it as a property (might not work)
-    try:
-        return blueprint.get_editor_property('generated_class')
-    except:
-        pass
-    
-    return None
-
-def get_blueprint_parent_class(blueprint):
-    """
-    Get the parent class from a blueprint.
-    """
-    try:
-        # Try getting it as a property
-        return blueprint.get_editor_property('parent_class')
-    except:
-        pass
-    
-    # Default to Actor for most blueprints
-    return unreal.Actor if hasattr(unreal, 'Actor') else None
-
-def get_class_name(unreal_class):
-    """
-    Get the name of an Unreal class object safely.
-    """
-    if not unreal_class:
-        return "None"
-    
-    # Try various methods to get the class name
-    try:
-        if hasattr(unreal_class, '__name__'):
-            return unreal_class.__name__
-    except:
-        pass
-    
-    try:
-        if hasattr(unreal_class, 'get_name'):
-            # get_name() is a method on instances, not classes
-            # So we need to be careful here
-            return str(unreal_class).split('.')[-1].replace("'", "").replace('>', '')
-    except:
-        pass
-    
-    # Fallback to string representation
-    class_str = str(unreal_class)
-    if '.' in class_str:
-        return class_str.split('.')[-1].replace("'", "").replace('>', '')
-    
-    return class_str
-
-def ensure_kismet_system_library():
-    """
-    Try to import KismetSystemLibrary if available.
-    Note: This library might not be available in all UE versions or configurations.
-    """
-    try:
-        # KismetSystemLibrary is part of the BlueprintGraph module
-        # It might not be exposed to Python in all versions
-        if hasattr(unreal, 'KismetSystemLibrary'):
-            return unreal.KismetSystemLibrary
-        
-        # Try alternate import methods
-        import importlib
-        try:
-            kismet = importlib.import_module('unreal.KismetSystemLibrary')
-            return kismet
-        except:
-            pass
-    except:
-        pass
-    
-    return None

package/src/python-utils.ts

@@ -1,57 +0,0 @@
-/**
- * Python Utilities for Modern Unreal Engine API
- * 
- * This module provides Python code snippets that use the modern
- * Unreal Engine Python API instead of deprecated functions.
- */
-
-export class PythonUtils {
-  /**
-   * Get all actors in the level using modern API
-   * @returns Python code to get all level actors
-   */
-  static getAllLevelActors(): string {
-    return `
-# Use modern EditorActorSubsystem instead of deprecated EditorLevelLibrary
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-actors = editor_actor_subsystem.get_all_level_actors()
-`.trim();
-  }
-
-  /**
-   * Get selected actors using modern API
-   * @returns Python code to get selected actors
-   */
-  static getSelectedActors(): string {
-    return `
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-selected_actors = editor_actor_subsystem.get_selected_level_actors()
-`.trim();
-  }
-
-  /**
-   * Spawn actor from class using modern API
-   * @returns Python code to spawn actor
-   */
-  static spawnActorFromClass(): string {
-    return `
-editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-# Use spawn_actor_from_class for spawning
-`.trim();
-  }
-
-  /**
-   * Get a safe way to access actors
-   * @returns Python code with modern API
-   */
-  static getSafeActorAccess(): string {
-    return `
-# Use modern API
-try:
-    editor_actor_subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    actors = editor_actor_subsystem.get_all_level_actors() if editor_actor_subsystem else []
-except:
-    actors = []
-`.trim();
-  }
-}