unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/introspection.js

@@ -1,17 +1,33 @@
 import { Logger } from '../utils/logger.js';
-import { bestEffortInterpretedText, interpretStandardResult } from '../utils/result-helpers.js';
+import { lookupPropertyMetadata, normalizeDictionaryKey } from './property-dictionary.js';
 export class IntrospectionTools {
     bridge;
+    automationBridge;
     log = new Logger('IntrospectionTools');
     objectCache = new Map();
     retryAttempts = 3;
     retryDelay = 1000;
-    constructor(bridge) {
+    propertyFilterPatterns = [
+        /internal/i,
+        /transient/i,
+        /^temp/i,
+        /^bhidden/i,
+        /renderstate/i,
+        /previewonly/i,
+        /deprecated/i
+    ];
+    ignoredPropertyKeys = new Set([
+        'assetimportdata',
+        'blueprintcreatedcomponents',
+        'componentreplicator',
+        'componentoverrides',
+        'actorcomponenttags'
+    ]);
+    constructor(bridge, automationBridge) {
         this.bridge = bridge;
+        this.automationBridge = automationBridge;
     }
-    /**
-     * Execute with retry logic for transient failures
-     */
+    setAutomationBridge(automationBridge) { this.automationBridge = automationBridge; }
     async executeWithRetry(operation, operationName) {
         let lastError;
         for (let attempt = 1; attempt <= this.retryAttempts; attempt++) {
@@ -28,40 +44,7 @@ export class IntrospectionTools {
         }
         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 output = bestEffortInterpretedText(interpreted) ?? '';
-        if (output) {
-            this.log.error(`Failed to parse ${operationName} result: ${output}`);
-        }
-        if (output.includes('ModuleNotFoundError')) {
-            return { success: false, error: 'Reflection module not available.' };
-        }
-        if (output.includes('AttributeError')) {
-            return { success: false, error: 'Reflection API method not found. Check Unreal Engine version compatibility.' };
-        }
-        return {
-            success: false,
-            error: `${interpreted.error ?? `${operationName} did not return a valid result`}: ${output.substring(0, 200)}`
-        };
-    }
-    /**
-     * Convert Unreal property value to JavaScript-friendly format
-     */
     convertPropertyValue(value, typeName) {
-        // Handle vectors, rotators, transforms
         if (typeName.includes('Vector')) {
             if (typeof value === 'object' && value !== null) {
                 return { x: value.X || 0, y: value.Y || 0, z: value.Z || 0 };
@@ -83,258 +66,246 @@ export class IntrospectionTools {
         }
         return value;
     }
+    isPlainObject(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+    isLikelyPropertyDescriptor(value) {
+        if (!this.isPlainObject(value))
+            return false;
+        if (typeof value.name === 'string' && ('value' in value || 'type' in value))
+            return true;
+        if ('propertyName' in value && ('currentValue' in value || 'defaultValue' in value))
+            return true;
+        return false;
+    }
+    shouldFilterProperty(name, value, flags, detailed = false) {
+        if (detailed)
+            return false;
+        if (!name)
+            return true;
+        const normalized = normalizeDictionaryKey(name);
+        if (this.ignoredPropertyKeys.has(normalized))
+            return true;
+        for (const pattern of this.propertyFilterPatterns) {
+            if (pattern.test(name))
+                return true;
+        }
+        if (Array.isArray(value) && value.length === 0)
+            return true;
+        if (this.isPlainObject(value) && Object.keys(value).length === 0)
+            return true;
+        if (flags?.some((f) => /deprecated/i.test(f)))
+            return true;
+        return false;
+    }
+    formatDisplayValue(value, type) {
+        if (value === null || value === undefined)
+            return 'None';
+        if (typeof value === 'string')
+            return value.length > 120 ? `${value.slice(0, 117)}...` : value;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return `${value}`;
+        if (Array.isArray(value)) {
+            const preview = value.slice(0, 5).map((entry) => this.formatDisplayValue(entry, typeof entry));
+            const suffix = value.length > 5 ? `, … (+${value.length - 5})` : '';
+            return `[${preview.join(', ')}${suffix}]`;
+        }
+        if (this.isPlainObject(value)) {
+            const keys = Object.keys(value);
+            if (['vector', 'rotator', 'transform'].some((token) => type.toLowerCase().includes(token))) {
+                const printable = Object.entries(value)
+                    .map(([k, v]) => `${k}: ${this.formatDisplayValue(v, typeof v)}`)
+                    .join(', ');
+                return `{ ${printable} }`;
+            }
+            const preview = keys.slice(0, 5).map((k) => `${k}: ${this.formatDisplayValue(value[k], typeof value[k])}`);
+            const suffix = keys.length > 5 ? `, … (+${keys.length - 5} keys)` : '';
+            return `{ ${preview.join(', ')}${suffix} }`;
+        }
+        return String(value);
+    }
+    normalizePropertyEntry(entry, detailed = false) {
+        if (!entry)
+            return null;
+        const name = entry.name ?? entry.propertyName ?? entry.key ?? '';
+        if (!name)
+            return null;
+        const candidateType = entry.type ?? entry.propertyType ?? (entry.value !== undefined ? typeof entry.value : undefined);
+        const type = typeof candidateType === 'string' && candidateType.length > 0 ? candidateType : 'unknown';
+        const rawValue = entry.value ?? entry.currentValue ?? entry.defaultValue ?? entry.data ?? entry;
+        const value = this.convertPropertyValue(rawValue, type);
+        const flags = entry.flags ?? entry.attributes;
+        const metadata = entry.metadata ?? entry.annotations;
+        const filtered = this.shouldFilterProperty(name, value, flags, detailed);
+        const dictionaryEntry = lookupPropertyMetadata(name);
+        const propertyInfo = {
+            name,
+            type,
+            value,
+            flags,
+            metadata,
+            category: dictionaryEntry?.category ?? entry.category,
+            tooltip: entry.tooltip ?? entry.helpText,
+            description: dictionaryEntry?.description ?? entry.description,
+            displayValue: this.formatDisplayValue(value, type),
+            dictionaryEntry,
+            isReadOnly: Boolean(entry.isReadOnly || entry.readOnly || flags?.some((f) => f.toLowerCase().includes('readonly')))
+        };
+        propertyInfo.__filtered = filtered;
+        return propertyInfo;
+    }
+    flattenPropertyMap(source, prefix = '', detailed = false) {
+        const properties = [];
+        for (const [rawKey, rawValue] of Object.entries(source)) {
+            const name = prefix ? `${prefix}.${rawKey}` : rawKey;
+            if (this.isLikelyPropertyDescriptor(rawValue)) {
+                const normalized = this.normalizePropertyEntry({ ...rawValue, name }, detailed);
+                if (normalized)
+                    properties.push(normalized);
+                continue;
+            }
+            if (this.isPlainObject(rawValue)) {
+                const nestedKeys = Object.keys(rawValue);
+                const hasPrimitiveChildren = nestedKeys.some((key) => {
+                    const child = rawValue[key];
+                    return child === null || typeof child !== 'object' || Array.isArray(child) || this.isLikelyPropertyDescriptor(child);
+                });
+                if (hasPrimitiveChildren) {
+                    const normalized = this.normalizePropertyEntry({ name, value: rawValue }, detailed);
+                    if (normalized)
+                        properties.push(normalized);
+                }
+                else {
+                    properties.push(...this.flattenPropertyMap(rawValue, name, detailed));
+                }
+                continue;
+            }
+            const normalized = this.normalizePropertyEntry({ name, value: rawValue }, detailed);
+            if (normalized)
+                properties.push(normalized);
+        }
+        return properties;
+    }
+    extractRawProperties(rawInfo, detailed = false) {
+        if (!rawInfo)
+            return [];
+        if (Array.isArray(rawInfo.properties)) {
+            const entries = rawInfo.properties;
+            return entries
+                .map((entry) => this.normalizePropertyEntry(entry, detailed))
+                .filter((entry) => Boolean(entry));
+        }
+        if (this.isPlainObject(rawInfo.properties)) {
+            return this.flattenPropertyMap(rawInfo.properties, '', detailed);
+        }
+        if (Array.isArray(rawInfo)) {
+            const entries = rawInfo;
+            return entries
+                .map((entry) => this.normalizePropertyEntry(entry, detailed))
+                .filter((entry) => Boolean(entry));
+        }
+        if (this.isPlainObject(rawInfo)) {
+            const shallow = { ...rawInfo };
+            delete shallow.properties;
+            delete shallow.functions;
+            delete shallow.summary;
+            return this.flattenPropertyMap(shallow, '', detailed);
+        }
+        return [];
+    }
+    curateObjectInfo(rawInfo, objectPath, detailed = false) {
+        const properties = this.extractRawProperties(rawInfo, detailed);
+        const filteredProperties = [];
+        const curatedProperties = properties.filter((prop) => {
+            const shouldFilter = prop.__filtered;
+            delete prop.__filtered;
+            if (shouldFilter) {
+                filteredProperties.push(prop.name);
+            }
+            return !shouldFilter;
+        });
+        const categories = {};
+        const finalList = (detailed ? properties : curatedProperties).map((prop) => {
+            const category = (prop.category ?? prop.dictionaryEntry?.category ?? 'General');
+            categories[category] = (categories[category] ?? 0) + 1;
+            return prop;
+        });
+        const summary = {
+            name: rawInfo?.name ?? rawInfo?.objectName ?? rawInfo?.displayName,
+            class: rawInfo?.class ?? rawInfo?.className ?? rawInfo?.type ?? rawInfo?.objectClass,
+            path: rawInfo?.path ?? rawInfo?.objectPath ?? objectPath,
+            parent: rawInfo?.outer ?? rawInfo?.parent,
+            tags: Array.isArray(rawInfo?.tags) ? rawInfo.tags : undefined,
+            propertyCount: properties.length,
+            curatedPropertyCount: curatedProperties.length,
+            filteredPropertyCount: filteredProperties.length,
+            categories
+        };
+        const info = {
+            class: summary.class,
+            name: summary.name,
+            path: summary.path,
+            parent: summary.parent,
+            tags: summary.tags,
+            properties: finalList,
+            functions: Array.isArray(rawInfo?.functions) ? rawInfo.functions : undefined,
+            interfaces: Array.isArray(rawInfo?.interfaces) ? rawInfo.interfaces : undefined,
+            flags: Array.isArray(rawInfo?.flags) ? rawInfo.flags : undefined,
+            summary,
+            filteredProperties: filteredProperties.length ? filteredProperties : undefined,
+            original: rawInfo
+        };
+        return info;
+    }
     async inspectObject(params) {
-        // Check cache first if not requesting detailed info
         if (!params.detailed && this.objectCache.has(params.objectPath)) {
             const cached = this.objectCache.get(params.objectPath);
             if (cached) {
                 return { success: true, info: cached };
             }
         }
-        const py = `
-import unreal, json, inspect
-path = r"${params.objectPath}"
-detailed = ${params.detailed ? 'True' : 'False'}
-
-def get_property_info(prop, obj=None):
-    """Extract detailed property information"""
-    try:
-        info = {
-            'name': prop.get_name(),
-            'type': prop.get_property_class_name() if hasattr(prop, 'get_property_class_name') else 'Unknown'
-        }
-        
-        # Try to get property flags
-        flags = []
-        if hasattr(prop, 'has_any_property_flags'):
-            if prop.has_any_property_flags(unreal.PropertyFlags.CPF_EDIT_CONST):
-                flags.append('ReadOnly')
-            if prop.has_any_property_flags(unreal.PropertyFlags.CPF_BLUEPRINT_READ_ONLY):
-                flags.append('BlueprintReadOnly')
-            if prop.has_any_property_flags(unreal.PropertyFlags.CPF_TRANSIENT):
-                flags.append('Transient')
-        info['flags'] = flags
-        
-        # Try to get metadata
-        if hasattr(prop, 'get_metadata'):
-            try:
-                info['category'] = prop.get_metadata('Category')
-                info['tooltip'] = prop.get_metadata('ToolTip')
-            except Exception:
-                pass
-        
-        # Try to get current value if object provided
-        if obj and detailed:
-            try:
-                value = getattr(obj, prop.get_name())
-                # Convert complex types to serializable format
-                if hasattr(value, '__dict__'):
-                    value = str(value)
-                info['value'] = value
-            except Exception:
-                pass
-        
-        return info
-    except Exception as e:
-        return {'name': str(prop) if prop else 'Unknown', 'type': 'Unknown', 'error': str(e)}
-
-try:
-    obj = unreal.load_object(None, path)
-    if not obj:
-        # Try as class if object load fails
-        try:
-            obj = unreal.load_class(None, path)
-            if not obj:
-                print('RESULT:' + json.dumps({'success': False, 'error': 'Object or class not found'}))
-                raise SystemExit(0)
-        except Exception:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Object not found'}))
-            raise SystemExit(0)
-    
-    info = {
-        'class': obj.get_class().get_name() if hasattr(obj, 'get_class') else str(type(obj)),
-        'name': obj.get_name() if hasattr(obj, 'get_name') else '',
-        'path': path,
-        'properties': [],
-        'functions': [],
-        'flags': []
-    }
-    
-    # Get parent class
-    try:
-        if hasattr(obj, 'get_class'):
-            cls = obj.get_class()
-            if hasattr(cls, 'get_super_class'):
-                super_cls = cls.get_super_class()
-                if super_cls:
-                    info['parent'] = super_cls.get_name()
-    except Exception:
-        pass
-    
-    # Get object flags
-    try:
-        if hasattr(obj, 'has_any_flags'):
-            flags = []
-            if obj.has_any_flags(unreal.ObjectFlags.RF_PUBLIC):
-                flags.append('Public')
-            if obj.has_any_flags(unreal.ObjectFlags.RF_TRANSIENT):
-                flags.append('Transient')
-            if obj.has_any_flags(unreal.ObjectFlags.RF_DEFAULT_SUB_OBJECT):
-                flags.append('DefaultSubObject')
-            info['flags'] = flags
-    except Exception:
-        pass
-    
-    # Get properties - AVOID deprecated properties completely
-    props = []
-    
-    # List of deprecated properties to completely skip
-    deprecated_props = [
-        'life_span', 'on_actor_touch', 'on_actor_un_touch',
-        'get_touching_actors', 'get_touching_components',
-        'controller_class', 'look_up_scale', 'sound_wave_param',
-        'material_substitute', 'texture_object'
-    ]
-    
-    try:
-        cls = obj.get_class() if hasattr(obj, 'get_class') else obj
-        
-        # Try UE5 reflection API with safe property access
-        if hasattr(cls, 'get_properties'):
-            for prop in cls.get_properties():
-                prop_name = None
-                try:
-                    # Safe property name extraction
-                    if hasattr(prop, 'get_name'):
-                        prop_name = prop.get_name()
-                    elif hasattr(prop, 'name'):
-                        prop_name = prop.name
-                    
-                    # Skip if deprecated
-                    if prop_name and prop_name not in deprecated_props:
-                        prop_info = get_property_info(prop, obj if detailed else None)
-                        if prop_info.get('name') not in deprecated_props:
-                            props.append(prop_info)
-                except Exception:
-                    pass
-        
-        # If reflection API didn't work, use a safe property list
-        if not props:
-            # Only access known safe properties
-            safe_properties = [
-                'actor_guid', 'actor_instance_guid', 'always_relevant',
-                'auto_destroy_when_finished', 'can_be_damaged',
-                'content_bundle_guid', 'custom_time_dilation',
-                'enable_auto_lod_generation', 'find_camera_component_when_view_target',
-                'generate_overlap_events_during_level_streaming', 'hidden',
-                'initial_life_span',  # Use new name instead of life_span
-                'instigator', 'is_spatially_loaded', 'min_net_update_frequency',
-                'net_cull_distance_squared', 'net_dormancy', 'net_priority',
-                'net_update_frequency', 'net_use_owner_relevancy',
-                'only_relevant_to_owner', 'pivot_offset',
-                'replicate_using_registered_sub_object_list', 'replicates',
-                'root_component', 'runtime_grid', 'spawn_collision_handling_method',
-                'sprite_scale', 'tags', 'location', 'rotation', 'scale'
-            ]
-            
-            for prop_name in safe_properties:
-                try:
-                    # Use get_editor_property for safer access
-                    if hasattr(obj, 'get_editor_property'):
-                        val = obj.get_editor_property(prop_name)
-                        props.append({
-                            'name': prop_name,
-                            'type': type(val).__name__ if val is not None else 'None',
-                            'value': str(val)[:100] if detailed and val is not None else None
-                        })
-                    elif hasattr(obj, prop_name):
-                        # Direct access only for safe properties
-                        val = getattr(obj, prop_name)
-                        if not callable(val):
-                            props.append({
-                                'name': prop_name,
-                                'type': type(val).__name__,
-                                'value': str(val)[:100] if detailed else None
-                            })
-                except Exception:
-                    pass
-    except Exception as e:
-        # Minimal fallback with only essential safe properties
-        pass
-    
-    info['properties'] = props
-    
-    # Get functions/methods if detailed
-    if detailed:
-        funcs = []
-        try:
-            cls = obj.get_class() if hasattr(obj, 'get_class') else obj
-            
-            # Try to get UFunctions
-            if hasattr(cls, 'get_functions'):
-                for func in cls.get_functions():
-                    func_info = {
-                        'name': func.get_name(),
-                        'parameters': [],
-                        'flags': []
-                    }
-                    # Get parameters if possible
-                    if hasattr(func, 'get_params'):
-                        for param in func.get_params():
-                            func_info['parameters'].append({
-                                'name': param.get_name() if hasattr(param, 'get_name') else str(param),
-                                'type': 'Unknown'
-                            })
-                    funcs.append(func_info)
-            else:
-                # Fallback: use known safe function names
-                safe_functions = [
-                    'get_actor_location', 'set_actor_location',
-                    'get_actor_rotation', 'set_actor_rotation',
-                    'get_actor_scale', 'set_actor_scale',
-                    'destroy_actor', 'destroy_component',
-                    'get_components', 'get_component_by_class',
-                    'add_actor_component', 'add_component',
-                    'get_world', 'get_name', 'get_path_name',
-                    'is_valid', 'is_a', 'has_authority'
-                ]
-                for func_name in safe_functions:
-                    if hasattr(obj, func_name):
-                        try:
-                            attr_value = getattr(obj, func_name)
-                            if callable(attr_value):
-                                funcs.append({
-                                    'name': func_name,
-                                    'parameters': [],
-                                    'flags': []
-                                })
-                        except Exception:
-                            pass
-        except Exception:
-            pass
-        
-        info['functions'] = funcs
-    
-    print('RESULT:' + json.dumps({'success': True, 'info': info}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(py), 'inspectObject');
-        const result = this.parsePythonResult(resp, 'inspectObject');
-        // Cache the result if successful and not detailed
-        if (result.success && result.info && !params.detailed) {
-            this.objectCache.set(params.objectPath, result.info);
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Introspection operations require plugin support.');
         }
-        return result;
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('inspect_object', {
+                    objectPath: params.objectPath,
+                    detailed: params.detailed ?? false
+                }, {
+                    timeoutMs: 60000
+                });
+                if (response.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to inspect object'
+                    };
+                }
+                const rawInfo = response.info ?? response.result ?? response.data ?? response;
+                const curatedInfo = this.curateObjectInfo(rawInfo, params.objectPath, params.detailed ?? false);
+                const result = {
+                    success: true,
+                    info: curatedInfo
+                };
+                if (result.success && result.info && !params.detailed) {
+                    this.objectCache.set(params.objectPath, result.info);
+                }
+                return result;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to inspect object: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'inspectObject');
     }
     async setProperty(params) {
         return this.executeWithRetry(async () => {
             try {
-                // Validate and convert value type if needed
                 let processedValue = params.value;
-                // Handle special Unreal types
                 if (typeof params.value === 'object' && params.value !== null) {
-                    // Vector conversion
                     if ('x' in params.value || 'X' in params.value) {
                         processedValue = {
                             X: params.value.x || params.value.X || 0,
@@ -342,7 +313,6 @@ except Exception as e:
                             Z: params.value.z || params.value.Z || 0
                         };
                     }
-                    // Rotator conversion
                     else if ('pitch' in params.value || 'Pitch' in params.value) {
                         processedValue = {
                             Pitch: params.value.pitch || params.value.Pitch || 0,
@@ -350,7 +320,6 @@ except Exception as e:
                             Roll: params.value.roll || params.value.Roll || 0
                         };
                     }
-                    // Transform conversion
                     else if ('location' in params.value || 'Location' in params.value) {
                         processedValue = {
                             Translation: this.convertPropertyValue(params.value.location || params.value.Location, 'Vector'),
@@ -359,14 +328,15 @@ except Exception as e:
                         };
                     }
                 }
-                const res = await this.bridge.httpCall('/remote/object/property', 'PUT', {
+                const res = await this.bridge.setObjectProperty({
                     objectPath: params.objectPath,
                     propertyName: params.propertyName,
-                    propertyValue: processedValue
+                    value: processedValue
                 });
-                // Clear cache for this object
-                this.objectCache.delete(params.objectPath);
-                return { success: true, result: res };
+                if (res.success) {
+                    this.objectCache.delete(params.objectPath);
+                }
+                return res;
             }
             catch (err) {
                 const errorMsg = err?.message || String(err);
@@ -380,300 +350,187 @@ except Exception as e:
             }
         }, 'setProperty');
     }
-    /**
-     * Get property value of an object
-     */
     async getProperty(params) {
-        const py = `
-import unreal, json
-path = r"${params.objectPath}"
-prop_name = r"${params.propertyName}"
-try:
-    obj = unreal.load_object(None, path)
-    if not obj:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Object not found'}))
-    else:
-        # Try different methods to get property
-        value = None
-        found = False
-        
-        # Method 1: Direct attribute access
-        if hasattr(obj, prop_name):
-            try:
-                value = getattr(obj, prop_name)
-                found = True
-            except Exception:
-                pass
-        
-        # Method 2: get_editor_property (UE4/5)
-        if not found and hasattr(obj, 'get_editor_property'):
-            try:
-                value = obj.get_editor_property(prop_name)
-                found = True
-            except Exception:
-                pass
-        
-        # Method 3: Try with common property name variations
-        if not found:
-            # Try common property name variations
-            variations = [
-                prop_name,
-                prop_name.lower(),
-                prop_name.upper(),
-                prop_name.capitalize(),
-                # Convert snake_case to CamelCase
-                ''.join(word.capitalize() for word in prop_name.split('_')),
-                # Convert CamelCase to snake_case
-                ''.join(['_' + c.lower() if c.isupper() else c for c in prop_name]).lstrip('_')
-            ]
-            for variant in variations:
-                if hasattr(obj, variant):
-                    try:
-                        value = getattr(obj, variant)
-                        found = True
-                        break
-                    except Exception:
-                        pass
-        
-        if found:
-            # Convert complex types to string
-            if hasattr(value, '__dict__'):
-                value = str(value)
-            elif isinstance(value, (list, tuple, dict)):
-                value = json.dumps(value)
-            
-            print('RESULT:' + json.dumps({'success': True, 'value': value}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': f'Property {prop_name} not found'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(py), 'getProperty');
-        return this.parsePythonResult(resp, 'getProperty');
+        return this.executeWithRetry(async () => {
+            const result = await this.bridge.getObjectProperty({
+                objectPath: params.objectPath,
+                propertyName: params.propertyName
+            });
+            return result;
+        }, 'getProperty');
     }
-    /**
-     * Call a function on an object
-     */
     async callFunction(params) {
-        const py = `
-import unreal, json
-path = r"${params.objectPath}"
-func_name = r"${params.functionName}"
-params = ${JSON.stringify(params.parameters || [])}
-try:
-    obj = unreal.load_object(None, path)
-    if not obj:
-        # Try loading as class if object fails
-        try:
-            obj = unreal.load_class(None, path)
-        except:
-            pass
-    
-    if not obj:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Object not found'}))
-    else:
-        # For KismetMathLibrary or similar utility classes, use static method call
-        if 'KismetMathLibrary' in path or 'MathLibrary' in path or 'GameplayStatics' in path:
-            try:
-                # Use Unreal's MathLibrary (KismetMathLibrary is exposed as MathLibrary in Python)
-                if func_name.lower() == 'abs':
-                    # Use Unreal's MathLibrary.abs function
-                    result = unreal.MathLibrary.abs(float(params[0])) if params else 0
-                    print('RESULT:' + json.dumps({'success': True, 'result': result}))
-                elif func_name.lower() == 'sqrt':
-                    # Use Unreal's MathLibrary.sqrt function
-                    result = unreal.MathLibrary.sqrt(float(params[0])) if params else 0
-                    print('RESULT:' + json.dumps({'success': True, 'result': result}))
-                else:
-                    # Try to call as static method
-                    if hasattr(obj, func_name):
-                        func = getattr(obj, func_name)
-                        if callable(func):
-                            result = func(*params) if params else func()
-                            if hasattr(result, '__dict__'):
-                                result = str(result)
-                            print('RESULT:' + json.dumps({'success': True, 'result': result}))
-                        else:
-                            print('RESULT:' + json.dumps({'success': False, 'error': f'{func_name} is not callable'}))
-                    else:
-                        # Try snake_case version
-                        snake_case_name = ''.join(['_' + c.lower() if c.isupper() else c for c in func_name]).lstrip('_')
-                        if hasattr(obj, snake_case_name):
-                            func = getattr(obj, snake_case_name)
-                            result = func(*params) if params else func()
-                            print('RESULT:' + json.dumps({'success': True, 'result': result}))
-                        else:
-                            print('RESULT:' + json.dumps({'success': False, 'error': f'Function {func_name} not found'}))
-            except Exception as e:
-                print('RESULT:' + json.dumps({'success': False, 'error': f'Function call failed: {str(e)}'}))
-        else:
-            # Regular object method call
-            if hasattr(obj, func_name):
-                func = getattr(obj, func_name)
-                if callable(func):
-                    try:
-                        result = func(*params) if params else func()
-                        # Convert result to serializable format
-                        if hasattr(result, '__dict__'):
-                            result = str(result)
-                        print('RESULT:' + json.dumps({'success': True, 'result': result}))
-                    except Exception as e:
-                        print('RESULT:' + json.dumps({'success': False, 'error': f'Function call failed: {str(e)}'}))
-                else:
-                    print('RESULT:' + json.dumps({'success': False, 'error': f'{func_name} is not callable'}))
-            else:
-                print('RESULT:' + json.dumps({'success': False, 'error': f'Function {func_name} not found'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(py), 'callFunction');
-        return this.parsePythonResult(resp, 'callFunction');
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Function call operations require plugin support.');
+        }
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('call_object_function', {
+                    objectPath: params.objectPath,
+                    functionName: params.functionName,
+                    parameters: params.parameters || []
+                }, {
+                    timeoutMs: 60000
+                });
+                if (response.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to call function'
+                    };
+                }
+                return {
+                    success: true,
+                    result: response.result
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to call function: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'callFunction');
     }
-    /**
-     * Get Class Default Object (CDO) for a class
-     */
     async getCDO(className) {
-        const py = `
-import unreal, json
-class_name = r"${className}"
-try:
-    # Try to find the class
-    cls = None
-    
-    # Method 1: Direct class load
-    try:
-        cls = unreal.load_class(None, class_name)
-    except Exception:
-        pass
-    
-    # Method 2: Find class by name
-    if not cls:
-        try:
-            cls = unreal.find_class(class_name)
-        except Exception:
-            pass
-    
-    # Method 3: Search in loaded classes
-    if not cls:
-        for obj in unreal.ObjectLibrary.get_all_objects():
-            if hasattr(obj, 'get_class'):
-                obj_cls = obj.get_class()
-                if obj_cls.get_name() == class_name:
-                    cls = obj_cls
-                    break
-    
-    if not cls:
-        print('RESULT:' + json.dumps({'success': False, 'error': 'Class not found'}))
-    else:
-        # Get CDO
-        cdo = cls.get_default_object() if hasattr(cls, 'get_default_object') else None
-        
-        if cdo:
-            info = {
-                'className': cls.get_name(),
-                'cdoPath': cdo.get_path_name() if hasattr(cdo, 'get_path_name') else '',
-                'properties': []
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. CDO operations require plugin support.');
+        }
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('inspect', {
+                    action: 'inspect_class',
+                    classPath: className
+                }, {
+                    timeoutMs: 60000
+                });
+                if (response?.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to get CDO'
+                    };
+                }
+                return {
+                    success: true,
+                    cdo: response?.data ?? response?.result ?? response
+                };
             }
-            
-            # Get default property values using safe property list
-            safe_cdo_properties = [
-                'initial_life_span', 'hidden', 'can_be_damaged', 'replicates',
-                'always_relevant', 'net_dormancy', 'net_priority',
-                'net_update_frequency', 'replicate_movement',
-                'actor_guid', 'tags', 'root_component',
-                'auto_destroy_when_finished', 'enable_auto_lod_generation'
-            ]
-            for prop_name in safe_cdo_properties:
-                try:
-                    if hasattr(cdo, 'get_editor_property'):
-                        value = cdo.get_editor_property(prop_name)
-                        info['properties'].append({
-                            'name': prop_name,
-                            'defaultValue': str(value)[:100]
-                        })
-                    elif hasattr(cdo, prop_name):
-                        value = getattr(cdo, prop_name)
-                        if not callable(value):
-                            info['properties'].append({
-                                'name': prop_name,
-                                'defaultValue': str(value)[:100]
-                            })
-                except Exception:
-                    pass
-            
-            print('RESULT:' + json.dumps({'success': True, 'cdo': info}))
-        else:
-            print('RESULT:' + json.dumps({'success': False, 'error': 'Could not get CDO'}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(py), 'getCDO');
-        return this.parsePythonResult(resp, 'getCDO');
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to get CDO: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'getCDO');
     }
-    /**
-     * Search for objects by class
-     */
     async findObjectsByClass(className, limit = 100) {
-        const py = `
-import unreal, json
-class_name = r"${className}"
-limit = ${limit}
-try:
-    objects = []
-    count = 0
-    
-    # Use EditorAssetLibrary to find assets
-    try:
-        all_assets = unreal.EditorAssetLibrary.list_assets("/Game", recursive=True)
-        for asset_path in all_assets:
-            if count >= limit:
-                break
-            try:
-                asset = unreal.EditorAssetLibrary.load_asset(asset_path)
-                if asset:
-                    asset_class = asset.get_class() if hasattr(asset, 'get_class') else None
-                    if asset_class and class_name in asset_class.get_name():
-                        objects.append({
-                            'path': asset_path,
-                            'name': asset.get_name() if hasattr(asset, 'get_name') else '',
-                            'class': asset_class.get_name()
-                        })
-                        count += 1
-            except Exception:
-                pass
-    except Exception as e:
-        print('RESULT:' + json.dumps({'success': False, 'error': f'Asset search failed: {str(e)}'}))
-        raise SystemExit(0)
-    
-    # Also search in level actors
-    try:
-        actor_sub = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
-        if actor_sub:
-            for actor in actor_sub.get_all_level_actors():
-                if count >= limit:
-                    break
-                if actor:
-                    actor_class = actor.get_class() if hasattr(actor, 'get_class') else None
-                    if actor_class and class_name in actor_class.get_name():
-                        objects.append({
-                            'path': actor.get_path_name() if hasattr(actor, 'get_path_name') else '',
-                            'name': actor.get_actor_label() if hasattr(actor, 'get_actor_label') else '',
-                            'class': actor_class.get_name()
-                        })
-                        count += 1
-    except Exception:
-        pass
-    
-    print('RESULT:' + json.dumps({'success': True, 'objects': objects, 'count': len(objects)}))
-except Exception as e:
-    print('RESULT:' + json.dumps({'success': False, 'error': str(e)}))
-`.trim();
-        const resp = await this.executeWithRetry(() => this.bridge.executePython(py), 'findObjectsByClass');
-        return this.parsePythonResult(resp, 'findObjectsByClass');
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Object search operations require plugin support.');
+        }
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('inspect', {
+                    action: 'find_by_class',
+                    className,
+                    limit
+                }, {
+                    timeoutMs: 60000
+                });
+                if (response?.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to find objects'
+                    };
+                }
+                const data = response?.data ?? response?.result ?? response;
+                const validObjects = Array.isArray(data?.actors)
+                    ? data.actors
+                    : (Array.isArray(data?.objects) ? data.objects : (Array.isArray(data) ? data : []));
+                return {
+                    success: true,
+                    message: `Found ${validObjects.length} objects`,
+                    objects: validObjects,
+                    count: validObjects.length
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to find objects: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'findObjectsByClass');
+    }
+    async getComponentProperty(params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Component property operations require plugin support.');
+        }
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('get_component_property', {
+                    objectPath: params.objectPath,
+                    componentName: params.componentName,
+                    propertyName: params.propertyName
+                }, {
+                    timeoutMs: 15000
+                });
+                if (response.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to get component property'
+                    };
+                }
+                return {
+                    success: true,
+                    value: response.value,
+                    type: response.type
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to get component property: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'getComponentProperty');
+    }
+    async setComponentProperty(params) {
+        if (!this.automationBridge) {
+            throw new Error('Automation Bridge not available. Component property operations require plugin support.');
+        }
+        const automationBridge = this.automationBridge;
+        return this.executeWithRetry(async () => {
+            try {
+                const response = await automationBridge.sendAutomationRequest('set_component_property', {
+                    objectPath: params.objectPath,
+                    componentName: params.componentName,
+                    propertyName: params.propertyName,
+                    value: params.value
+                }, {
+                    timeoutMs: 15000
+                });
+                if (response.success === false) {
+                    return {
+                        success: false,
+                        error: response.error || response.message || 'Failed to set component property'
+                    };
+                }
+                return {
+                    success: true,
+                    message: response.message || 'Property set successfully'
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: `Failed to set component property: ${error instanceof Error ? error.message : String(error)}`
+                };
+            }
+        }, 'setComponentProperty');
     }
-    /**
-     * Clear object cache
-     */
     clearCache() {
         this.objectCache.clear();
     }