unreal-engine-mcp-server 0.4.6 → 0.5.0

package/src/tools/base-tool.ts

@@ -0,0 +1,52 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
+import { IBaseTool } from '../types/tool-interfaces.js';
+
+export abstract class BaseTool implements IBaseTool {
+    constructor(protected bridge: UnrealBridge) { }
+
+    getAutomationBridge(): AutomationBridge {
+        return this.bridge.getAutomationBridge();
+    }
+
+    protected async sendRequest(action: string, params: Record<string, unknown>, toolName: string = 'unknown_tool', options?: { timeoutMs?: number }): Promise<any> {
+        const automation = this.getAutomationBridge();
+
+        // Basic validation
+        if (!automation.isConnected()) {
+            throw new Error(`Automation bridge not connected for ${toolName}`);
+        }
+
+        const response = await automation.sendAutomationRequest(toolName, {
+            action,
+            ...params
+        }, options);
+
+        if (!response || response.success === false) {
+            let errorMessage = `Failed to execute ${action} in ${toolName}`;
+            if (response?.error) {
+                if (typeof response.error === 'string') {
+                    errorMessage = response.error;
+                } else if (typeof response.error === 'object') {
+                    const errObj = response.error as any;
+                    if (errObj.message) {
+                        errorMessage = `${errObj.message} (Code: ${errObj.code || 'UNKNOWN'})`;
+                    }
+                }
+            } else if (response?.message) {
+                errorMessage = response.message;
+            }
+            throw new Error(errorMessage);
+        }
+
+        return response.result ?? response;
+    }
+
+    protected async sendAutomationRequest(action: string, params: Record<string, unknown> = {}, options?: { timeoutMs?: number; waitForEvent?: boolean; waitForEventTimeoutMs?: number }): Promise<any> {
+        const automation = this.getAutomationBridge();
+        if (!automation.isConnected()) {
+            throw new Error('Automation bridge not connected');
+        }
+        return automation.sendAutomationRequest(action, params, options);
+    }
+}

package/src/tools/behavior-tree.ts

@@ -0,0 +1,45 @@
+import { BaseTool } from './base-tool.js';
+
+export class BehaviorTreeTools extends BaseTool {
+  private async sendAction(subAction: string, payload: Record<string, unknown> = {}) {
+    try {
+        const response: any = await this.sendAutomationRequest('manage_behavior_tree', {
+            subAction,
+            ...payload
+        });
+        
+        return {
+            success: response?.success ?? false,
+            message: response?.message,
+            error: response?.error,
+            result: response?.result
+        };
+    } catch (e: any) {
+        return { success: false, error: String(e) };
+    }
+  }
+
+  async addNode(params: { assetPath: string; nodeType: string; x: number; y: number }) {
+    return this.sendAction('add_node', params);
+  }
+
+  async connectNodes(params: { assetPath: string; parentNodeId: string; childNodeId: string }) {
+    return this.sendAction('connect_nodes', params);
+  }
+
+  async removeNode(params: { assetPath: string; nodeId: string }) {
+    return this.sendAction('remove_node', params);
+  }
+  
+  async breakConnections(params: { assetPath: string; nodeId: string }) {
+    return this.sendAction('break_connections', params);
+  }
+
+  async setNodeProperties(params: { assetPath: string; nodeId: string; comment?: string; properties?: Record<string, unknown> }) {
+    return this.sendAction('set_node_properties', params);
+  }
+
+  async create(params: { name: string; savePath?: string }) {
+    return this.sendAction('create', params);
+  }
+}

package/src/tools/blueprint/helpers.ts

@@ -0,0 +1,189 @@
+import { coerceString } from '../../utils/result-helpers.js';
+
+// Helper utilities extracted from the large BlueprintTools implementation
+// to keep the main file more focused. These are pure helpers and safe to
+// reuse across the class methods.
+
+export type TransformInput = {
+  location?: unknown;
+  rotation?: unknown;
+  scale?: unknown;
+};
+
+export function toFiniteNumber(raw: unknown): number | undefined {
+  if (typeof raw === 'number' && Number.isFinite(raw)) return raw;
+  if (typeof raw === 'string') {
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) return undefined;
+    const parsed = Number(trimmed);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return undefined;
+}
+
+export function normalizePartialVector(value: unknown, alternateKeys: string[] = ['x', 'y', 'z']): Record<string, number> | undefined {
+  if (value === undefined || value === null) {
+    return undefined;
+  }
+
+  const result: Record<string, number> = {};
+
+  const assignIfPresent = (component: 'x' | 'y' | 'z', raw: unknown) => {
+    const numberValue = toFiniteNumber(raw);
+    if (numberValue !== undefined) {
+      result[component] = numberValue;
+    }
+  };
+
+  if (Array.isArray(value)) {
+    if (value.length > 0) assignIfPresent('x', value[0]);
+    if (value.length > 1) assignIfPresent('y', value[1]);
+    if (value.length > 2) assignIfPresent('z', value[2]);
+  } else if (typeof value === 'object') {
+    const obj = value as Record<string, unknown>;
+    assignIfPresent('x', obj.x ?? obj[alternateKeys[0]]);
+    assignIfPresent('y', obj.y ?? obj[alternateKeys[1]]);
+    assignIfPresent('z', obj.z ?? obj[alternateKeys[2]]);
+  } else {
+    assignIfPresent('x', value);
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+export function normalizeTransformInput(transform: TransformInput | undefined): Record<string, unknown> | undefined {
+  if (!transform || typeof transform !== 'object') return undefined;
+  const result: Record<string, unknown> = {};
+  const location = normalizePartialVector(transform.location);
+  if (location) result.location = location;
+  const rotation = normalizePartialVector(transform.rotation, ['pitch', 'yaw', 'roll']);
+  if (rotation) result.rotation = rotation;
+  const scale = normalizePartialVector(transform.scale);
+  if (scale) result.scale = scale;
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+export type BlueprintScsOperationInput = {
+  type: string;
+  componentName?: string;
+  componentClass?: string;
+  attachTo?: string;
+  transform?: TransformInput;
+  properties?: Record<string, unknown>;
+};
+
+export function sanitizeScsOperation(rawOperation: BlueprintScsOperationInput, index: number): { ok: true; operation: Record<string, unknown> } | { ok: false; error: string } {
+  if (!rawOperation || typeof rawOperation !== 'object') {
+    return { ok: false, error: `Operation at index ${index} must be an object.` };
+  }
+
+  const type = (rawOperation.type || '').toString().trim().toLowerCase();
+  if (!type) return { ok: false, error: `Operation at index ${index} missing type.` };
+  const operation: Record<string, unknown> = { type };
+
+  // Type-safe access to properties
+  const op = rawOperation as Record<string, any>;
+  const componentName = op.componentName ?? op.name;
+  const componentClass = op.componentClass ?? op.componentType ?? op.class;
+  const attachTo = op.attachTo ?? op.parent ?? op.attach;
+  const transform = normalizeTransformInput(op.transform);
+  const properties = rawOperation.properties && typeof rawOperation.properties === 'object' ? rawOperation.properties : undefined;
+
+  switch (type) {
+    case 'add_component': {
+      if (!componentName) return { ok: false, error: `add_component operation at index ${index} requires componentName.` };
+      if (!componentClass) return { ok: false, error: `add_component operation for ${componentName} missing componentClass.` };
+      operation.componentName = componentName;
+      operation.componentClass = componentClass;
+      if (attachTo) operation.attachTo = attachTo;
+      if (transform) operation.transform = transform;
+      if (properties) operation.properties = properties;
+      break;
+    }
+    case 'remove_component': {
+      if (!componentName) return { ok: false, error: `remove_component operation at index ${index} requires componentName.` };
+      operation.componentName = componentName;
+      break;
+    }
+    case 'set_component_properties': {
+      if (!componentName) return { ok: false, error: `set_component_properties operation at index ${index} requires componentName.` };
+      if (!properties) return { ok: false, error: `set_component_properties operation at index ${index} missing properties object.` };
+      operation.componentName = componentName;
+      operation.properties = properties;
+      if (transform) operation.transform = transform;
+      break;
+    }
+    case 'modify_component': {
+      if (!componentName) return { ok: false, error: `modify_component operation at index ${index} requires componentName.` };
+      if (!transform && !properties) return { ok: false, error: `modify_component operation at index ${index} requires transform or properties.` };
+      operation.componentName = componentName;
+      if (transform) operation.transform = transform;
+      if (properties) operation.properties = properties;
+      break;
+    }
+    case 'attach_component': {
+      const parent = op.parentComponent ?? op.parent;
+      if (!componentName) return { ok: false, error: `attach_component operation at index ${index} requires componentName.` };
+      if (!parent) return { ok: false, error: `attach_component operation at index ${index} requires parentComponent.` };
+      operation.componentName = componentName;
+      operation.attachTo = parent;
+      break;
+    }
+    default:
+      return { ok: false, error: `Unknown SCS operation type: ${type}` };
+  }
+
+  return { ok: true, operation };
+}
+
+export function resolveBlueprintCandidates(rawName: string | undefined): { primary: string | undefined; candidates: string[] } {
+  const trimmed = coerceString(rawName)?.trim();
+  if (!trimmed) return { primary: undefined, candidates: [] };
+
+  // Normalize slashes and remove duplicates (global flag fixed)
+  const normalized = trimmed.replace(/\\/g, '/').replace(/\/+/g, '/');
+  const withoutLeading = normalized.replace(/^\/+/, '');
+  
+  // Build a prioritized list using a Set to handle uniqueness automatically
+  const candidates = new Set<string>();
+  
+  const add = (path: string) => {
+    if (path && path.trim()) candidates.add(path.replace(/\/+/g, '/'));
+  };
+
+  if (normalized.includes('/')) {
+    // Path-like input: try to guess standard content paths first
+    const basename = withoutLeading.split('/').pop();
+    if (basename) {
+      add(`/Game/Blueprints/${basename}`);
+      add(`/Game/${basename}`);
+    }
+    add(normalized);
+    add(normalized.startsWith('/') ? normalized : `/${withoutLeading}`);
+  } else {
+    // Bare name: try standard locations
+    add(`/Game/Blueprints/${withoutLeading}`);
+    add(`/Game/${withoutLeading}`);
+    add(normalized);
+    add(`/${withoutLeading}`);
+  }
+
+  const ordered = Array.from(candidates);
+  return { primary: ordered[0], candidates: ordered };
+}
+
+ 
+
+export function inferVariableTypeFromValue(value: unknown): string | undefined {
+  if (value === null || value === undefined) return undefined;
+  if (typeof value === 'boolean') return 'Bool';
+  if (typeof value === 'number') return Number.isInteger(value) ? 'Int' : 'Float';
+  if (typeof value === 'string') return 'String';
+  if (Array.isArray(value)) return 'Array';
+  if (typeof value === 'object') {
+    const keys = Object.keys(value as Record<string, unknown>);
+    if (keys.includes('x') && keys.includes('y') && keys.includes('z')) return 'Vector';
+    return 'Struct';
+  }
+  return undefined;
+}