unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/base-tool.d.ts

@@ -0,0 +1,17 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
+import { IBaseTool } from '../types/tool-interfaces.js';
+export declare abstract class BaseTool implements IBaseTool {
+    protected bridge: UnrealBridge;
+    constructor(bridge: UnrealBridge);
+    getAutomationBridge(): AutomationBridge;
+    protected sendRequest(action: string, params: Record<string, unknown>, toolName?: string, options?: {
+        timeoutMs?: number;
+    }): Promise<any>;
+    protected sendAutomationRequest(action: string, params?: Record<string, unknown>, options?: {
+        timeoutMs?: number;
+        waitForEvent?: boolean;
+        waitForEventTimeoutMs?: number;
+    }): Promise<any>;
+}
+//# sourceMappingURL=base-tool.d.ts.map

package/dist/tools/base-tool.js

@@ -0,0 +1,46 @@
+export class BaseTool {
+    bridge;
+    constructor(bridge) {
+        this.bridge = bridge;
+    }
+    getAutomationBridge() {
+        return this.bridge.getAutomationBridge();
+    }
+    async sendRequest(action, params, toolName = 'unknown_tool', options) {
+        const automation = this.getAutomationBridge();
+        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;
+                    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;
+    }
+    async sendAutomationRequest(action, params = {}, options) {
+        const automation = this.getAutomationBridge();
+        if (!automation.isConnected()) {
+            throw new Error('Automation bridge not connected');
+        }
+        return automation.sendAutomationRequest(action, params, options);
+    }
+}
+//# sourceMappingURL=base-tool.js.map

package/dist/tools/behavior-tree.d.ts

@@ -0,0 +1,94 @@
+import { BaseTool } from './base-tool.js';
+export declare class BehaviorTreeTools extends BaseTool {
+    private sendAction;
+    addNode(params: {
+        assetPath: string;
+        nodeType: string;
+        x: number;
+        y: number;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    connectNodes(params: {
+        assetPath: string;
+        parentNodeId: string;
+        childNodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    removeNode(params: {
+        assetPath: string;
+        nodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    breakConnections(params: {
+        assetPath: string;
+        nodeId: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    setNodeProperties(params: {
+        assetPath: string;
+        nodeId: string;
+        comment?: string;
+        properties?: Record<string, unknown>;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+    create(params: {
+        name: string;
+        savePath?: string;
+    }): Promise<{
+        success: any;
+        message: any;
+        error: any;
+        result: any;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        result?: undefined;
+    }>;
+}
+//# sourceMappingURL=behavior-tree.d.ts.map

package/dist/tools/behavior-tree.js

@@ -0,0 +1,39 @@
+import { BaseTool } from './base-tool.js';
+export class BehaviorTreeTools extends BaseTool {
+    async sendAction(subAction, payload = {}) {
+        try {
+            const response = await this.sendAutomationRequest('manage_behavior_tree', {
+                subAction,
+                ...payload
+            });
+            return {
+                success: response?.success ?? false,
+                message: response?.message,
+                error: response?.error,
+                result: response?.result
+            };
+        }
+        catch (e) {
+            return { success: false, error: String(e) };
+        }
+    }
+    async addNode(params) {
+        return this.sendAction('add_node', params);
+    }
+    async connectNodes(params) {
+        return this.sendAction('connect_nodes', params);
+    }
+    async removeNode(params) {
+        return this.sendAction('remove_node', params);
+    }
+    async breakConnections(params) {
+        return this.sendAction('break_connections', params);
+    }
+    async setNodeProperties(params) {
+        return this.sendAction('set_node_properties', params);
+    }
+    async create(params) {
+        return this.sendAction('create', params);
+    }
+}
+//# sourceMappingURL=behavior-tree.js.map

package/dist/tools/blueprint/helpers.d.ts

@@ -0,0 +1,29 @@
+export type TransformInput = {
+    location?: unknown;
+    rotation?: unknown;
+    scale?: unknown;
+};
+export declare function toFiniteNumber(raw: unknown): number | undefined;
+export declare function normalizePartialVector(value: unknown, alternateKeys?: string[]): Record<string, number> | undefined;
+export declare function normalizeTransformInput(transform: TransformInput | undefined): Record<string, unknown> | undefined;
+export type BlueprintScsOperationInput = {
+    type: string;
+    componentName?: string;
+    componentClass?: string;
+    attachTo?: string;
+    transform?: TransformInput;
+    properties?: Record<string, unknown>;
+};
+export declare function sanitizeScsOperation(rawOperation: BlueprintScsOperationInput, index: number): {
+    ok: true;
+    operation: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function resolveBlueprintCandidates(rawName: string | undefined): {
+    primary: string | undefined;
+    candidates: string[];
+};
+export declare function inferVariableTypeFromValue(value: unknown): string | undefined;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/tools/blueprint/helpers.js

@@ -0,0 +1,182 @@
+import { coerceString } from '../../utils/result-helpers.js';
+export function toFiniteNumber(raw) {
+    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, alternateKeys = ['x', 'y', 'z']) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const result = {};
+    const assignIfPresent = (component, raw) => {
+        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;
+        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) {
+    if (!transform || typeof transform !== 'object')
+        return undefined;
+    const result = {};
+    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 function sanitizeScsOperation(rawOperation, index) {
+    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 = { type };
+    const op = rawOperation;
+    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) {
+    const trimmed = coerceString(rawName)?.trim();
+    if (!trimmed)
+        return { primary: undefined, candidates: [] };
+    const normalized = trimmed.replace(/\\/g, '/').replace(/\/+/g, '/');
+    const withoutLeading = normalized.replace(/^\/+/, '');
+    const candidates = new Set();
+    const add = (path) => {
+        if (path && path.trim())
+            candidates.add(path.replace(/\/+/g, '/'));
+    };
+    if (normalized.includes('/')) {
+        const basename = withoutLeading.split('/').pop();
+        if (basename) {
+            add(`/Game/Blueprints/${basename}`);
+            add(`/Game/${basename}`);
+        }
+        add(normalized);
+        add(normalized.startsWith('/') ? normalized : `/${withoutLeading}`);
+    }
+    else {
+        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) {
+    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);
+        if (keys.includes('x') && keys.includes('y') && keys.includes('z'))
+            return 'Vector';
+        return 'Struct';
+    }
+    return undefined;
+}
+//# sourceMappingURL=helpers.js.map