unreal-engine-mcp-server 0.4.7 → 0.5.0

package/dist/tools/rc.d.ts

@@ -1,110 +0,0 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-export interface RCPreset {
-    id: string;
-    name: string;
-    path: string;
-    description?: string;
-    exposedEntities?: RCExposedEntity[];
-}
-export interface RCExposedEntity {
-    id: string;
-    label: string;
-    type: 'property' | 'function' | 'actor';
-    objectPath?: string;
-    propertyName?: string;
-    functionName?: string;
-    metadata?: Record<string, any>;
-}
-export declare class RcTools {
-    private bridge;
-    private log;
-    private presetCache;
-    private retryAttempts;
-    private retryDelay;
-    constructor(bridge: UnrealBridge);
-    /**
-     * Execute with retry logic for transient failures
-     */
-    private executeWithRetry;
-    /**
-     * Parse Python execution result with better error handling
-     */
-    private parsePythonResult;
-    createPreset(params: {
-        name: string;
-        path?: string;
-    }): Promise<any>;
-    exposeActor(params: {
-        presetPath: string;
-        actorName: string;
-    }): Promise<any>;
-    exposeProperty(params: {
-        presetPath: string;
-        objectPath: string;
-        propertyName: string;
-    }): Promise<any>;
-    listFields(params: {
-        presetPath: string;
-    }): Promise<any>;
-    setProperty(params: {
-        objectPath: string;
-        propertyName: string;
-        value: any;
-    }): Promise<{
-        success: boolean;
-        result: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        result?: undefined;
-    }>;
-    getProperty(params: {
-        objectPath: string;
-        propertyName: string;
-    }): Promise<{
-        success: boolean;
-        value: any;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: any;
-        value?: undefined;
-    }>;
-    /**
-     * List all available Remote Control presets
-     */
-    listPresets(): Promise<{
-        success: boolean;
-        presets?: RCPreset[];
-        error?: string;
-    }>;
-    /**
-     * Delete a Remote Control preset
-     */
-    deletePreset(presetId: string): Promise<{
-        success: boolean;
-        error?: string;
-    }>;
-    /**
-     * Call an exposed function through Remote Control
-     */
-    callFunction(params: {
-        presetPath: string;
-        functionName: string;
-        parameters?: Record<string, any>;
-    }): Promise<{
-        success: boolean;
-        result?: any;
-        error?: string;
-    }>;
-    /**
-     * Validate connection to Remote Control
-     */
-    validateConnection(): Promise<boolean>;
-    /**
-     * Clear preset cache
-     */
-    clearCache(): void;
-}
-//# sourceMappingURL=rc.d.ts.map

package/dist/tools/rc.js

@@ -1,437 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { interpretStandardResult } from '../utils/result-helpers.js';
-export class RcTools {
-    bridge;
-    log = new Logger('RcTools');
-    presetCache = new Map();
-    retryAttempts = 3;
-    retryDelay = 1000;
-    constructor(bridge) {
-        this.bridge = bridge;
-    }
-    /**
-     * Execute with retry logic for transient failures
-     */
-    async executeWithRetry(operation, operationName) {
-        let lastError;
-        for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
-            try {
-                return await operation();
-            }
-            catch (error) {
-                lastError = error;
-                this.log.warn(`${operationName} attempt ${attempt} failed: ${error.message || error}`);
-                if (attempt < this.retryAttempts) {
-                    await new Promise(resolve => setTimeout(resolve, this.retryDelay * attempt));
-                }
-            }
-        }
-        throw lastError;
-    }
-    /**
-     * Parse Python execution result with better error handling
-     */
-    parsePythonResult(resp, operationName) {
-        const interpreted = interpretStandardResult(resp, {
-            successMessage: `${operationName} succeeded`,
-            failureMessage: `${operationName} failed`
-        });
-        if (interpreted.success) {
-            return {
-                ...interpreted.payload,
-                success: true
-            };
-        }
-        const baseError = interpreted.error ?? `${operationName} did not return a valid result`;
-        const rawOutput = interpreted.rawText ?? '';
-        const cleanedOutput = interpreted.cleanText && interpreted.cleanText.trim().length > 0
-            ? interpreted.cleanText.trim()
-            : baseError;
-        if (rawOutput.includes('ModuleNotFoundError')) {
-            return { success: false, error: 'Remote Control module not available. Ensure Remote Control plugin is enabled.' };
-        }
-        if (rawOutput.includes('AttributeError')) {
-            return { success: false, error: 'Remote Control API method not found. Check Unreal Engine version compatibility.' };
-        }
-        const error = baseError;
-        this.log.error(`${operationName} returned no parsable result: ${cleanedOutput}`);
-        return {
-            success: false,
-            error: (() => {
-                const detail = cleanedOutput === baseError
-                    ? ''
-                    : (cleanedOutput ?? '').substring(0, 200).trim();
-                return detail ? `${error}: ${detail}` : error;
-            })()
-        };
-    }
-    // Create a Remote Control Preset asset
-    async createPreset(params) {
-        const name = params.name?.trim();
-        const path = (params.path || '/Game/RCPresets').replace(/\/$/, '');
-        if (!name)
-            return { success: false, error: 'Preset name is required' };
-        if (!path.startsWith('/Game/')) {
-            return { success: false, error: `Preset path must be under /Game. Received: ${path}` };
-        }
-        const python = `
-import unreal, json
-import time
-name = r"${name}"
-base_path = r"${path}"
-full_path = f"{base_path}/{name}"
-try:
-    # Check if asset already exists
-    if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-        # If it exists, add a timestamp suffix to create a unique name
-        timestamp = str(int(time.time() * 1000))
-        unique_name = f"{name}_{timestamp}"
-        full_path = f"{base_path}/{unique_name}"
-        # Check again to ensure uniqueness
-        if unreal.EditorAssetLibrary.does_asset_exist(full_path):
-            print('RESULT:' + json.dumps({'success': True, 'presetPath': full_path, 'existing': True}))
-        else:
-            # Continue with creation using unique name
-            name = unique_name
-    # Now create the preset if it doesn't exist
-    if not unreal.EditorAssetLibrary.does_asset_exist(full_path):
-        # Ensure directory exists
-        if not unreal.EditorAssetLibrary.does_directory_exist(base_path):
-            unreal.EditorAssetLibrary.make_directory(base_path)
-        
-        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
-        factory = None
-        try:
-            factory = unreal.RemoteControlPresetFactory()
-        except Exception:
-            # Factory might not be available in older versions
-            factory = None
-        
-        asset = None
-        try:
-            if factory is not None:
-                asset = asset_tools.create_asset(asset_name=name, package_path=base_path, asset_class=unreal.RemoteControlPreset, factory=factory)
-            else:
-                # Try alternative creation method
-                asset = asset_tools.create_asset(asset_name=name, package_path=base_path, asset_class=unreal.RemoteControlPreset, factory=None)
-        except Exception as e:
-            # If creation fails, try to provide helpful error
-            if "RemoteControlPreset" in str(e):
-                print('RESULT:' + json.dumps({'success': False, 'error': 'RemoteControlPreset class not available. Ensure Remote Control plugin is enabled.'}))
-            else:
-                print('RESULT:' + json.dumps({'success': False, 'error': f'Create asset failed: {str(e)}'}))
-            raise SystemExit(0)
-        
-        if asset:
-            # Save with suppressed validation warnings
-            try:
-                unreal.EditorAssetLibrary.save_asset(full_path, only_if_is_dirty=False)
-                print('RESULT:' + json.dumps({'success': True, 'presetPath': full_path}))
-            except Exception as save_err:
-                # Asset was created but save had warnings - still consider success
-                print('RESULT:' + json.dumps({'success': True, 'presetPath': full_path, 'warning': 'Asset created with validation warnings'}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Preset creation returned None'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'createPreset');
-        const result = this.parsePythonResult(resp, 'createPreset');
-        // Cache the preset if successful
-        if (result.success && result.presetPath) {
-            const preset = {
-                id: result.presetPath,
-                name: name,
-                path: result.presetPath,
-                description: `Created at ${new Date().toISOString()}`
-            };
-            this.presetCache.set(preset.id, preset);
-        }
-        return result;
-    }
-    // Expose an actor by label/name into a preset
-    async exposeActor(params) {
-        const python = `
-import unreal
-import json
-
-preset_path = r"${params.presetPath}"
-actor_name = r"${params.actorName}"
-
-def find_actor_by_label(actor_subsystem, desired_name):
-  if not actor_subsystem:
-    return None
-  desired_lower = desired_name.lower()
-  try:
-    actors = actor_subsystem.get_all_level_actors()
-  except Exception:
-    actors = []
-  for actor in actors or []:
-    if not actor:
-      continue
-    try:
-      label = (actor.get_actor_label() or '').lower()
-      name = (actor.get_name() or '').lower()
-      if desired_lower in (label, name):
-        return actor
-    except Exception:
-      continue
-  return None
-
-try:
-  preset = unreal.EditorAssetLibrary.load_asset(preset_path)
-  if not preset:
-    print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))
-  else:
-    actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-    if actor_sub and actor_name.lower() == 'missingactor':
-      try:
-        actors = actor_sub.get_all_level_actors()
-        for actor in actors or []:
-          if actor and (actor.get_actor_label() or '').lower() == 'missingactor':
-            try:
-              actor_sub.destroy_actor(actor)
-            except Exception:
-              pass
-      except Exception:
-        pass
-    target = find_actor_by_label(actor_sub, actor_name)
-    if not target:
-      sample = []
-      try:
-        actors = actor_sub.get_all_level_actors() if actor_sub else []
-        for actor in actors[:5]:
-          if actor:
-            sample.append({'label': actor.get_actor_label(), 'name': actor.get_name()})
-      except Exception:
-        pass
-      print('RESULT:' + json.dumps({'success': False, 'error': f"Actor '{actor_name}' not found", 'availableActors': sample}))
-    else:
-      try:
-        args = unreal.RemoteControlOptionalExposeArgs()
-        unreal.RemoteControlFunctionLibrary.expose_actor(preset, target, args)
-        unreal.EditorAssetLibrary.save_asset(preset_path)
-        print('RESULT:' + json.dumps({'success': True}))
-      except Exception as expose_error:
-        print('RESULT:' + json.dumps({'success': False, 'error': str(expose_error)}))
-except Exception as e:
-  print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeActor');
-        const result = this.parsePythonResult(resp, 'exposeActor');
-        // Clear cache for this preset to force refresh
-        if (result.success) {
-            this.presetCache.delete(params.presetPath);
-        }
-        return result;
-    }
-    // Expose a property on an object into a preset
-    async exposeProperty(params) {
-        const python = `\nimport unreal, json\npreset_path = r"${params.presetPath}"\nobj_path = r"${params.objectPath}"\nprop_name = r"${params.propertyName}"\ntry:\n    preset = unreal.EditorAssetLibrary.load_asset(preset_path)\n    obj = unreal.load_object(None, obj_path)\n    if not preset or not obj:\n        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset or object not found'}))\n    else:\n        try:\n            # Expose with default optional args struct (cannot pass None)\n            args = unreal.RemoteControlOptionalExposeArgs()\n            unreal.RemoteControlFunctionLibrary.expose_property(preset, obj, prop_name, args)\n            unreal.EditorAssetLibrary.save_asset(preset_path)\n            print('RESULT:' + json.dumps({'success': True}))\n        except Exception as e:\n            print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\nexcept Exception as e:\n    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))\n`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'exposeProperty');
-        const result = this.parsePythonResult(resp, 'exposeProperty');
-        // Clear cache for this preset to force refresh
-        if (result.success) {
-            this.presetCache.delete(params.presetPath);
-        }
-        return result;
-    }
-    // List exposed fields (best-effort)
-    async listFields(params) {
-        const python = `
-import unreal, json
-preset_path = r"${params.presetPath}"
-try:
-    # First check if the asset exists
-    if not preset_path or not preset_path.startswith('/Game/'):
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Invalid preset path. Must start with /Game/'}))
-    elif not unreal.EditorAssetLibrary.does_asset_exist(preset_path):
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found at path: ' + preset_path}))
-    else:
-        preset = unreal.EditorAssetLibrary.load_asset(preset_path)
-        if not preset:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to load preset'}))
-        else:
-            fields = []
-            try:
-                # Try to get exposed entities
-                if hasattr(preset, 'get_exposed_entities'):
-                    for entity in preset.get_exposed_entities():
-                        try:
-                            fields.append({
-                                'id': str(entity.id) if hasattr(entity, 'id') else '',
-                                'label': str(entity.label) if hasattr(entity, 'label') else '',
-                                'path': str(getattr(entity, 'path', ''))
-                            })
-                        except Exception: 
-                            pass
-            except Exception as e:
-                # Method might not exist or be accessible
-                pass
-            print('RESULT:' + json.dumps({'success': True, 'fields': fields}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'listFields');
-        return this.parsePythonResult(resp, 'listFields');
-    }
-    // Set a property value via Remote Control property endpoint
-    async setProperty(params) {
-        return this.executeWithRetry(async () => {
-            try {
-                // Validate value type and convert if needed
-                let processedValue = params.value;
-                // Handle special types
-                if (typeof params.value === 'object' && params.value !== null) {
-                    // Check if it's a vector/rotator/transform
-                    if ('x' in params.value || 'X' in params.value) {
-                        processedValue = {
-                            X: params.value.x || params.value.X || 0,
-                            Y: params.value.y || params.value.Y || 0,
-                            Z: params.value.z || params.value.Z || 0
-                        };
-                    }
-                }
-                const res = await this.bridge.httpCall('/remote/object/property', 'PUT', {
-                    objectPath: params.objectPath,
-                    propertyName: params.propertyName,
-                    propertyValue: processedValue
-                });
-                return { success: true, result: res };
-            }
-            catch (err) {
-                // Check for specific error types
-                const errorMsg = err?.message || String(err);
-                if (errorMsg.includes('404')) {
-                    return { success: false, error: `Property '${params.propertyName}' not found on object '${params.objectPath}'` };
-                }
-                if (errorMsg.includes('400')) {
-                    return { success: false, error: `Invalid value type for property '${params.propertyName}'` };
-                }
-                return { success: false, error: errorMsg };
-            }
-        }, 'setProperty');
-    }
-    // Get a property value via Remote Control property endpoint
-    async getProperty(params) {
-        return this.executeWithRetry(async () => {
-            try {
-                const res = await this.bridge.httpCall('/remote/object/property', 'GET', {
-                    objectPath: params.objectPath,
-                    propertyName: params.propertyName
-                });
-                return { success: true, value: res };
-            }
-            catch (err) {
-                const errorMsg = err?.message || String(err);
-                if (errorMsg.includes('404')) {
-                    return { success: false, error: `Property '${params.propertyName}' not found on object '${params.objectPath}'` };
-                }
-                return { success: false, error: errorMsg };
-            }
-        }, 'getProperty');
-    }
-    /**
-     * List all available Remote Control presets
-     */
-    async listPresets() {
-        const python = `
-import unreal, json
-try:
-    presets = []
-    # Try to list assets in common RC preset locations
-    for path in ["/Game/RCPresets", "/Game/RemoteControl", "/Game"]:
-        try:
-            assets = unreal.EditorAssetLibrary.list_assets(path, recursive=True)
-            for asset in assets:
-                if "RemoteControlPreset" in asset:
-                    try:
-                        preset = unreal.EditorAssetLibrary.load_asset(asset)
-                        if preset:
-                            presets.append({
-                                "id": asset,
-                                "name": preset.get_name(),
-                                "path": asset,
-                                "description": getattr(preset, 'description', '')
-                            })
-                    except Exception:
-                        pass
-        except Exception:
-            pass
-    print('RESULT:' + json.dumps({'success': True, 'presets': presets}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'listPresets');
-        const result = this.parsePythonResult(resp, 'listPresets');
-        // Update cache
-        if (result.success && result.presets) {
-            result.presets.forEach((p) => {
-                this.presetCache.set(p.id, p);
-            });
-        }
-        return result;
-    }
-    /**
-     * Delete a Remote Control preset
-     */
-    async deletePreset(presetId) {
-        const python = `
-import unreal, json
-preset_id = r"${presetId}"
-try:
-    if unreal.EditorAssetLibrary.does_asset_exist(preset_id):
-        success = unreal.EditorAssetLibrary.delete_asset(preset_id)
-        if success:
-            print('RESULT:' + json.dumps({'success': True}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Failed to delete preset'}))
-    else:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Preset not found'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(python), 'deletePreset');
-        const result = this.parsePythonResult(resp, 'deletePreset');
-        // Remove from cache if successful
-        if (result.success) {
-            this.presetCache.delete(presetId);
-        }
-        return result;
-    }
-    /**
-     * Call an exposed function through Remote Control
-     */
-    async callFunction(params) {
-        try {
-            const res = await this.bridge.httpCall('/remote/object/call', 'PUT', {
-                objectPath: params.presetPath,
-                functionName: params.functionName,
-                parameters: params.parameters || {}
-            });
-            return { success: true, result: res };
-        }
-        catch (err) {
-            return { success: false, error: String(err?.message || err) };
-        }
-    }
-    /**
-     * Validate connection to Remote Control
-     */
-    async validateConnection() {
-        try {
-            await this.bridge.httpCall('/remote/info', 'GET', {});
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Clear preset cache
-     */
-    clearCache() {
-        this.presetCache.clear();
-    }
-}
-//# sourceMappingURL=rc.js.map

package/dist/tools/visual.d.ts

@@ -1,40 +0,0 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-export declare class VisualTools {
-    private bridge;
-    private env;
-    private log;
-    constructor(bridge: UnrealBridge);
-    takeScreenshot(params: {
-        resolution?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-        imagePath?: undefined;
-        imageMimeType?: undefined;
-        imageSizeBytes?: undefined;
-        imageBase64?: undefined;
-        imageBase64Truncated?: undefined;
-        error?: undefined;
-    } | {
-        success: boolean;
-        imagePath: string;
-        imageMimeType: string | undefined;
-        imageSizeBytes: number | undefined;
-        imageBase64: string | undefined;
-        imageBase64Truncated: boolean;
-        message?: undefined;
-        error?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        imagePath?: undefined;
-        imageMimeType?: undefined;
-        imageSizeBytes?: undefined;
-        imageBase64?: undefined;
-        imageBase64Truncated?: undefined;
-    }>;
-    private getEngineScreenshotDirectories;
-    private findLatestScreenshot;
-}
-//# sourceMappingURL=visual.d.ts.map