unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/types/tool-interfaces.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-interfaces.js.map

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

@@ -1,7 +1,3 @@
-/**
- * Auto-generated TypeScript types from tool schemas
- * This provides type safety and IntelliSense support
- */
 export interface BaseToolResponse {
     success: boolean;
     message?: string;
@@ -18,6 +14,7 @@ export interface ManageAssetResponse extends BaseToolResponse {
     assets?: AssetInfo[];
     paths?: string[];
     materialPath?: string;
+    materialInstancePath?: string;
 }
 export interface Vector3D {
     x: number;
@@ -31,8 +28,25 @@ export interface Rotation3D {
 }
 export interface ControlActorResponse extends BaseToolResponse {
     actor?: string;
-    deleted?: string;
+    actorName?: string;
+    actorPath?: string;
+    componentName?: string;
+    componentPath?: string;
+    componentClass?: string;
+    componentPaths?: Array<{
+        name: string;
+        path: string;
+        class?: string;
+    }>;
+    components?: Array<Record<string, unknown>>;
+    actors?: Array<Record<string, unknown>>;
+    deleted?: string | string[];
+    deletedCount?: number;
+    missing?: string[];
     physicsEnabled?: boolean;
+    visible?: boolean;
+    tag?: string;
+    snapshotName?: string;
 }
 export interface ControlEditorResponse extends BaseToolResponse {
     playing?: boolean;
@@ -52,6 +66,13 @@ export interface AnimationPhysicsResponse extends BaseToolResponse {
     playing?: boolean;
     playRate?: number;
     ragdollActive?: boolean;
+    path?: string;
+    blendSpacePath?: string;
+    skeletonPath?: string;
+    controlRigPath?: string;
+    twoDimensional?: boolean;
+    warnings?: string[];
+    details?: unknown;
 }
 export interface CreateEffectResponse extends BaseToolResponse {
     effectName?: string;
@@ -123,6 +144,59 @@ export interface ToolParameters {
         actorName: string;
         force: Vector3D;
     };
+    SpawnBlueprintParams: {
+        blueprintPath: string;
+        actorName?: string;
+        location?: Vector3D;
+        rotation?: Rotation3D;
+    };
+    SetTransformParams: {
+        actorName: string;
+        location?: Vector3D;
+        rotation?: Rotation3D;
+        scale?: Vector3D;
+    };
+    SetVisibilityParams: {
+        actorName: string;
+        visible: boolean;
+    };
+    ComponentParams: {
+        actorName: string;
+        componentType?: string;
+        componentName?: string;
+        properties?: Record<string, unknown>;
+    };
+    DuplicateActorParams: {
+        actorName: string;
+        newName?: string;
+        offset?: Vector3D;
+    };
+    AttachActorParams: {
+        childActor: string;
+        parentActor: string;
+    };
+    DetachActorParams: {
+        actorName: string;
+    };
+    TagActorParams: {
+        actorName: string;
+        tag: string;
+    };
+    FindByTagParams: {
+        tag: string;
+        matchType?: string;
+    };
+    FindByNameParams: {
+        name: string;
+    };
+    BlueprintVariablesParams: {
+        actorName: string;
+        variables: Record<string, unknown>;
+    };
+    SnapshotActorParams: {
+        actorName: string;
+        snapshotName: string;
+    };
     SetCameraParams: {
         location?: Vector3D;
         rotation?: Rotation3D;
@@ -134,12 +208,12 @@ export interface ToolParameters {
         command: string;
     };
 }
-export type AssetAction = 'list' | 'import' | 'create_material';
-export type ActorAction = 'spawn' | 'delete' | 'apply_force';
+export type AssetAction = 'list' | 'import' | 'create_material' | 'create_material_instance';
+export type ActorAction = 'spawn' | 'spawn_blueprint' | 'delete' | 'delete_by_tag' | 'duplicate' | 'apply_force' | 'set_transform' | 'get_transform' | 'set_visibility' | 'add_component' | 'set_component_properties' | 'get_components' | 'add_tag' | 'find_by_tag' | 'find_by_name' | 'set_blueprint_variables' | 'create_snapshot' | 'attach' | 'detach';
 export type EditorAction = 'play' | 'stop' | 'set_camera' | 'set_view_mode';
 export type LevelAction = 'load' | 'save' | 'stream' | 'create_light' | 'build_lighting';
-export type AnimationAction = 'create_animation_bp' | 'play_montage' | 'setup_ragdoll';
-export type EffectAction = 'particle' | 'niagara' | 'debug_shape';
+export type AnimationAction = 'create_animation_bp' | 'create_anim_blueprint' | 'create_animation_blueprint' | 'play_montage' | 'play_anim_montage' | 'setup_ragdoll' | 'activate_ragdoll' | 'configure_vehicle' | 'create_blend_space' | 'create_state_machine' | 'setup_ik' | 'create_procedural_anim' | 'create_blend_tree' | 'setup_retargeting' | 'setup_physics_simulation' | 'create_animation_asset' | 'cleanup';
+export type EffectAction = 'particle' | 'niagara' | 'debug_shape' | 'spawn_niagara' | 'set_niagara_parameter' | 'clear_debug_shapes' | 'create_dynamic_light' | 'cleanup';
 export type BlueprintAction = 'create' | 'add_component';
 export type EnvironmentAction = 'create_landscape' | 'sculpt' | 'add_foliage' | 'paint_foliage';
 export type SystemAction = 'profile' | 'show_fps' | 'set_quality' | 'play_sound' | 'create_widget' | 'show_widget' | 'screenshot' | 'engine_start' | 'engine_quit' | 'read_log';
@@ -153,6 +227,8 @@ export interface ConsolidatedToolParams {
         destinationPath?: string;
         name?: string;
         path?: string;
+        parentMaterial?: string;
+        parameters?: Record<string, any>;
     };
     control_actor: {
         action: ActorAction;
@@ -160,13 +236,40 @@ export interface ConsolidatedToolParams {
         classPath?: string;
         location?: Vector3D;
         rotation?: Rotation3D;
+        scale?: Vector3D;
         force?: Vector3D;
+        blueprintPath?: string;
+        componentType?: string;
+        componentName?: string;
+        properties?: Record<string, unknown>;
+        visible?: boolean;
+        newName?: string;
+        offset?: Vector3D;
+        tag?: string;
+        matchType?: string;
+        variables?: Record<string, unknown>;
+        snapshotName?: string;
+        childActor?: string;
+        parentActor?: string;
+        actorNames?: string[];
     };
     control_editor: {
         action: EditorAction;
         location?: Vector3D;
         rotation?: Rotation3D;
         viewMode?: string;
+        speed?: number;
+        filename?: string;
+        fov?: number;
+        width?: number;
+        height?: number;
+        command?: string;
+        steps?: number;
+        frameRate?: number;
+        durationSeconds?: number;
+        bookmarkName?: string;
+        category?: string;
+        preferences?: Record<string, unknown>;
     };
     manage_level: {
         action: LevelAction;
@@ -185,13 +288,63 @@ export interface ConsolidatedToolParams {
         action: AnimationAction;
         name?: string;
         actorName?: string;
+        savePath?: string;
+        path?: string;
         skeletonPath?: string;
+        blueprintName?: string;
+        blueprintPath?: string;
         montagePath?: string;
         animationPath?: string;
         playRate?: number;
         physicsAssetName?: string;
         blendWeight?: number;
-        savePath?: string;
+        meshPath?: string;
+        assignToMesh?: boolean;
+        previewSkeleton?: string;
+        generateConstraints?: boolean;
+        vehicleName?: string;
+        vehicleType?: 'Car' | 'Bike' | 'Tank' | 'Aircraft' | string;
+        wheels?: Array<{
+            name: string;
+            radius: number;
+            width: number;
+            mass: number;
+            isSteering?: boolean;
+            isDriving?: boolean;
+        }>;
+        engine?: {
+            maxRPM: number;
+            torqueCurve: Array<[number, number]>;
+        };
+        transmission?: {
+            gears: number[];
+            finalDriveRatio: number;
+        };
+        pluginDependencies?: string[];
+        dimensions?: number | [number, number];
+        horizontalAxis?: {
+            name?: string;
+            minValue?: number;
+            maxValue?: number;
+        };
+        verticalAxis?: {
+            name?: string;
+            minValue?: number;
+            maxValue?: number;
+        };
+        samples?: any[];
+        states?: any[];
+        transitions?: any[];
+        chain?: any;
+        effector?: any;
+        sourceSkeleton?: string;
+        targetSkeleton?: string;
+        assets?: string[];
+        retargetAssets?: string[];
+        suffix?: string;
+        overwrite?: boolean;
+        artifacts?: string[];
+        assetType?: string;
     };
     create_effect: {
         action: EffectAction;
@@ -203,6 +356,20 @@ export interface ConsolidatedToolParams {
         shape?: string;
         size?: number;
         color?: [number, number, number, number];
+        lightName?: string;
+        lightType?: 'Point' | 'Spot' | 'Directional' | 'Rect' | string;
+        intensity?: number;
+        rotation?: Rotation3D;
+        pulse?: {
+            enabled?: boolean;
+            frequency?: number;
+        };
+        filter?: string;
+        systemName?: string;
+        parameterName?: string;
+        parameterType?: string;
+        value?: any;
+        isUserParameter?: boolean;
         duration?: number;
     };
     manage_blueprint: {
@@ -212,6 +379,9 @@ export interface ConsolidatedToolParams {
         componentType?: string;
         componentName?: string;
         savePath?: string;
+        waitForCompletion?: boolean;
+        applyAndSave?: boolean;
+        waitForCompletionTimeoutMs?: number;
     };
     build_environment: {
         action: EnvironmentAction;
@@ -240,15 +410,9 @@ export interface ConsolidatedToolParams {
         widgetName?: string;
         widgetType?: string;
         visible?: boolean;
-        resolution?: string;
-        projectPath?: string;
-        editorExe?: string;
-        filter_category?: string | string[];
-        filter_level?: 'Error' | 'Warning' | 'Log' | 'Verbose' | 'VeryVerbose' | 'All';
-        lines?: number;
-        log_path?: string;
-        include_prefixes?: string[];
-        exclude_categories?: string[];
+        width?: number;
+        height?: number;
+        windowed?: boolean;
     };
     console_command: {
         command: string;

package/dist/types/tool-types.js

@@ -1,6 +1,2 @@
-/**
- * Auto-generated TypeScript types from tool schemas
- * This provides type safety and IntelliSense support
- */
 export {};
 //# sourceMappingURL=tool-types.js.map

package/dist/unreal-bridge.d.ts

@@ -1,92 +1,42 @@
-interface RcCallBody {
-    objectPath: string;
-    functionName: string;
-    parameters?: Record<string, any>;
-    generateTransaction?: boolean;
-}
+import type { AutomationBridge } from './automation/index.js';
 export declare class UnrealBridge {
-    private ws?;
-    private http;
-    private env;
     private log;
     private connected;
-    private reconnectTimer?;
-    private reconnectAttempts;
-    private readonly MAX_RECONNECT_ATTEMPTS;
-    private readonly BASE_RECONNECT_DELAY;
-    private autoReconnectEnabled;
-    private engineVersionCache?;
-    private readonly ENGINE_VERSION_TTL_MS;
-    private lastPongReceived;
-    private pingInterval?;
-    private readonly PING_INTERVAL_MS;
-    private readonly PONG_TIMEOUT_MS;
+    private automationBridge?;
+    private automationBridgeListeners?;
     private commandQueue;
-    private isProcessing;
-    private readonly MIN_COMMAND_DELAY;
-    private readonly MAX_COMMAND_DELAY;
-    private readonly STAT_COMMAND_DELAY;
-    private lastCommandTime;
-    private lastStatCommandTime;
-    private consoleObjectCache;
-    private readonly CONSOLE_CACHE_TTL;
-    private pluginStatusCache;
-    private readonly PLUGIN_CACHE_TTL;
-    private readonly UNSAFE_VIEWMODES;
-    private readonly HARD_BLOCKED_VIEWMODES;
-    private readonly VIEWMODE_ALIASES;
-    private readonly PYTHON_TEMPLATES;
     get isConnected(): boolean;
-    /**
-     * Attempt to connect with exponential backoff retry strategy
-     * Uses optimized retry pattern from TypeScript best practices
-     * @param maxAttempts Maximum number of connection attempts
-     * @param timeoutMs Timeout for each connection attempt in milliseconds
-     * @param retryDelayMs Initial delay between retry attempts in milliseconds
-     * @returns Promise that resolves to true if connected, false otherwise
-     */
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
+    getAutomationBridge(): AutomationBridge;
     private connectPromise?;
     tryConnect(maxAttempts?: number, timeoutMs?: number, retryDelayMs?: number): Promise<boolean>;
     connect(timeoutMs?: number): Promise<void>;
-    httpCall<T = any>(path: string, method?: 'GET' | 'POST' | 'PUT', body?: any): Promise<T>;
-    private parsePythonJsonResult;
-    ensurePluginsEnabled(pluginNames: string[], context?: string): Promise<string[]>;
-    call(body: RcCallBody): Promise<any>;
-    getExposed(): Promise<any>;
-    executeConsoleCommand(command: string, options?: {
-        allowPython?: boolean;
-    }): Promise<any>;
-    summarizeConsoleCommand(command: string, response: any): {
-        command: string;
-        output: string;
-        logLines: any[];
-        returnValue: any;
-        raw: any;
-    };
+    private waitForAutomationConnection;
+    getObjectProperty(params: {
+        objectPath: string;
+        propertyName: string;
+        timeoutMs?: number;
+        allowAlternate?: boolean;
+    }): Promise<Record<string, any>>;
+    setObjectProperty(params: {
+        objectPath: string;
+        propertyName: string;
+        value: unknown;
+        markDirty?: boolean;
+        timeoutMs?: number;
+        allowAlternate?: boolean;
+    }): Promise<Record<string, any>>;
+    executeConsoleCommand(command: string, _options?: Record<string, never>): Promise<any>;
     executeConsoleCommands(commands: Iterable<string | {
         command: string;
         priority?: number;
-        allowPython?: boolean;
     }>, options?: {
         continueOnError?: boolean;
         delayMs?: number;
     }): Promise<any[]>;
-    executePython(command: string): Promise<any>;
-    setAutoReconnectEnabled(enabled: boolean): void;
-    private scheduleReconnect;
-    disconnect(): Promise<void>;
-    /**
-     * Enhanced Editor Function Access
-     * Use Python scripting as a bridge to access modern Editor Subsystem functions
-     */
-    executeEditorFunction(functionName: string, params?: Record<string, any>): Promise<any>;
-    /**
-     * Execute Python script and parse the result
-     */
-    executePythonWithResult(script: string): Promise<any>;
-    /**
-     * Get the Unreal Engine version via Python and parse major/minor/patch.
-     */
+    executeEditorFunction(functionName: string, params?: Record<string, any>, _options?: {
+        timeoutMs?: number;
+    }): Promise<any>;
     getEngineVersion(): Promise<{
         version: string;
         major: number;
@@ -94,71 +44,14 @@ export declare class UnrealBridge {
         patch: number;
         isUE56OrAbove: boolean;
     }>;
-    /**
-     * Query feature flags (Python availability, editor subsystems) via Python.
-     */
     getFeatureFlags(): Promise<{
-        pythonEnabled: boolean;
         subsystems: {
             unrealEditor: boolean;
             levelEditor: boolean;
             editorActor: boolean;
         };
     }>;
-    /**
-     * Fallback commands when Python is not available
-     */
-    private executeFallbackCommand;
-    /**
-     * SOLUTION 2: Safe ViewMode Switching
-     * Prevent crashes by validating and safely switching viewmodes
-     */
-    setSafeViewMode(mode: string): Promise<any>;
-    /**
-     * Get safe alternative for unsafe viewmodes
-     */
-    private getSafeAlternative;
-    /**
-     * SOLUTION 3: Command Throttling and Queueing
-     * Prevent rapid command execution that can overwhelm the engine
-     */
     private executeThrottledCommand;
-    /**
-     * Process command queue with appropriate delays
-     */
-    private processCommandQueue;
-    /**
-     * Calculate appropriate delay based on command priority and type
-     */
-    private calculateDelay;
-    /**
-     * SOLUTION 4: Enhanced Asset Creation
-     * Use Python scripting for complex asset creation that requires editor scripting
-     */
-    createComplexAsset(assetType: string, params: Record<string, any>): Promise<any>;
-    /**
-     * Start the command processor
-     */
-    private startCommandProcessor;
-    /**
-     * Clean expired entries from console object cache
-     */
-    private cleanConsoleCache;
-    /**
-     * Helper delay function
-     */
     private delay;
-    /**
-     * Batch command execution with proper delays
-     */
-    executeBatch(commands: Array<{
-        command: string;
-        priority?: number;
-    }>): Promise<any[]>;
-    /**
-     * Get safe console commands for common operations
-     */
-    getSafeCommands(): Record<string, string>;
 }
-export {};
 //# sourceMappingURL=unreal-bridge.d.ts.map