unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/graphql/resolvers.js

@@ -0,0 +1,746 @@
+export const scalarResolvers = {
+    Vector: {
+        serialize: (value) => {
+            if (!value)
+                return null;
+            return typeof value === 'object' && 'x' in value && 'y' in value && 'z' in value
+                ? value
+                : null;
+        },
+        parseValue: (value) => value,
+        parseLiteral: (ast) => {
+            if (ast.kind === 'ObjectValue') {
+                const value = {};
+                ast.fields.forEach((field) => {
+                    value[field.name.value] = field.value.value;
+                });
+                return value;
+            }
+            return null;
+        }
+    },
+    Rotator: {
+        serialize: (value) => {
+            if (!value)
+                return null;
+            return typeof value === 'object' && 'pitch' in value && 'yaw' in value && 'roll' in value
+                ? value
+                : null;
+        },
+        parseValue: (value) => value,
+        parseLiteral: (ast) => {
+            if (ast.kind === 'ObjectValue') {
+                const value = {};
+                ast.fields.forEach((field) => {
+                    value[field.name.value] = field.value.value;
+                });
+                return value;
+            }
+            return null;
+        }
+    },
+    Transform: {
+        serialize: (value) => value,
+        parseValue: (value) => value,
+        parseLiteral: (ast) => {
+            if (ast.kind === 'ObjectValue') {
+                const value = {};
+                ast.fields.forEach((field) => {
+                    if (field.value.kind === 'ObjectValue') {
+                        value[field.name.value] = {};
+                        field.value.fields.forEach((f) => {
+                            value[field.name.value][f.name.value] = f.value.value;
+                        });
+                    }
+                    else {
+                        value[field.name.value] = field.value.value;
+                    }
+                });
+                return value;
+            }
+            return null;
+        }
+    },
+    JSON: {
+        serialize: (value) => value,
+        parseValue: (value) => value,
+        parseLiteral: (ast) => {
+            switch (ast.kind) {
+                case 'StringValue':
+                    return ast.value;
+                case 'BooleanValue':
+                    return ast.value;
+                case 'IntValue':
+                case 'FloatValue':
+                    return Number(ast.value);
+                case 'ObjectValue':
+                    const value = {};
+                    ast.fields.forEach((field) => {
+                        value[field.name.value] = scalarResolvers.JSON.parseLiteral(field.value);
+                    });
+                    return value;
+                case 'ListValue':
+                    return ast.values.map((v) => scalarResolvers.JSON.parseLiteral(v));
+                default:
+                    return null;
+            }
+        }
+    }
+};
+import { Logger } from '../utils/logger.js';
+const log = new Logger('GraphQL:Resolvers');
+class GraphQLResolverError extends Error {
+    extensions;
+    constructor(message, code = 'UNREAL_ENGINE_ERROR', originalError) {
+        super(message);
+        this.name = 'GraphQLResolverError';
+        this.extensions = {
+            code,
+            originalError: originalError?.message
+        };
+    }
+}
+function createResolverError(operation, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`${operation} failed:`, message);
+    return new GraphQLResolverError(`${operation} failed: ${message}`, 'UNREAL_ENGINE_ERROR', error instanceof Error ? error : undefined);
+}
+function logAutomationFailure(source, response) {
+    try {
+        if (!response || response.success !== false) {
+            return;
+        }
+        const errorText = (response.error || response.message || '').toString();
+        if (errorText.length === 0) {
+            return;
+        }
+        log.error(`${source} automation failure:`, errorText);
+    }
+    catch {
+    }
+}
+async function getActorProperties(bridge, actorName) {
+    try {
+        const result = await bridge.getObjectProperty({
+            objectPath: actorName,
+            propertyName: '*',
+            timeoutMs: 5000
+        });
+        return result.success ? result.value || {} : {};
+    }
+    catch (error) {
+        log.error('Failed to get actor properties:', error);
+        return {};
+    }
+}
+async function listAssets(automationBridge, filter, pagination) {
+    try {
+        const response = await automationBridge.sendAutomationRequest('list_assets', {
+            filter: filter || {},
+            pagination: pagination || { offset: 0, limit: 50 }
+        }, { timeoutMs: 30000 });
+        if (response.success && response.result) {
+            const result = response.result;
+            return {
+                assets: result.assets || [],
+                totalCount: result.totalCount || 0
+            };
+        }
+        logAutomationFailure('list_assets', response);
+        log.warn('Failed to list assets - returning empty set');
+        return { assets: [], totalCount: 0 };
+    }
+    catch (error) {
+        log.error('Failed to list assets:', error);
+        throw createResolverError('listAssets', error);
+    }
+}
+async function listActors(automationBridge, filter) {
+    try {
+        const response = await automationBridge.sendAutomationRequest('list_actors', {
+            filter: filter || {}
+        }, { timeoutMs: 30000 });
+        if (response.success && response.result) {
+            const result = response.result;
+            return {
+                actors: result.actors || []
+            };
+        }
+        logAutomationFailure('list_actors', response);
+        return { actors: [] };
+    }
+    catch (error) {
+        console.error('Failed to list actors:', error);
+        return { actors: [] };
+    }
+}
+export const resolvers = {
+    Query: {
+        assets: async (_, args, context) => {
+            const { filter, pagination } = args;
+            const { assets, totalCount } = await listAssets(context.automationBridge, filter, pagination);
+            const edges = assets.map((asset, index) => ({
+                node: asset,
+                cursor: Buffer.from(`${asset.path}:${index}`).toString('base64')
+            }));
+            return {
+                edges,
+                pageInfo: {
+                    hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
+                    hasPreviousPage: (pagination?.offset || 0) > 0,
+                    startCursor: edges.length > 0 ? edges[0].cursor : null,
+                    endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                },
+                totalCount
+            };
+        },
+        asset: async (_, { path }, context) => {
+            try {
+                if (!context.loaders) {
+                    throw new Error('Loaders not initialized');
+                }
+                return await context.loaders.assetLoader.load(path);
+            }
+            catch (error) {
+                console.error('Failed to get asset:', error);
+                return null;
+            }
+        },
+        actors: async (_, args, context) => {
+            const { filter, pagination } = args;
+            const { actors } = await listActors(context.automationBridge, filter);
+            const offset = pagination?.offset ?? 0;
+            const limit = pagination?.limit ?? 50;
+            const paginatedActors = actors.slice(offset, offset + limit);
+            const edges = paginatedActors.map((actor, index) => ({
+                node: actor,
+                cursor: Buffer.from(`${actor.name}:${offset + index}`).toString('base64')
+            }));
+            return {
+                edges,
+                pageInfo: {
+                    hasNextPage: offset + paginatedActors.length < actors.length,
+                    hasPreviousPage: offset > 0,
+                    startCursor: edges.length > 0 ? edges[0].cursor : null,
+                    endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                },
+                totalCount: actors.length
+            };
+        },
+        actor: async (_, { name }, context) => {
+            try {
+                if (!context.loaders) {
+                    throw new Error('Loaders not initialized');
+                }
+                return await context.loaders.actorLoader.load(name);
+            }
+            catch (error) {
+                console.error('Failed to get actor:', error);
+                return null;
+            }
+        },
+        blueprints: async (_, args, context) => {
+            const { filter, pagination } = args;
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('list_blueprints', {
+                    filter: filter || {},
+                    pagination: pagination || { offset: 0, limit: 50 }
+                }, { timeoutMs: 30000 });
+                const blueprints = response.success && response.result
+                    ? response.result.blueprints || []
+                    : [];
+                const edges = blueprints.map((blueprint, index) => ({
+                    node: blueprint,
+                    cursor: Buffer.from(`${blueprint.path}:${index}`).toString('base64')
+                }));
+                return {
+                    edges,
+                    pageInfo: {
+                        hasNextPage: (pagination?.offset || 0) + blueprints.length < response.result?.totalCount || 0,
+                        hasPreviousPage: (pagination?.offset || 0) > 0,
+                        startCursor: edges.length > 0 ? edges[0].cursor : null,
+                        endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                    },
+                    totalCount: blueprints.length
+                };
+            }
+            catch (error) {
+                console.error('Failed to list blueprints:', error);
+                return {
+                    edges: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                        startCursor: null,
+                        endCursor: null
+                    },
+                    totalCount: 0
+                };
+            }
+        },
+        blueprint: async (_, { path }, context) => {
+            if (!context.loaders) {
+                throw new Error('Loaders not initialized');
+            }
+            return await context.loaders.blueprintLoader.load(path);
+        },
+        levels: async (_, __, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('list_levels', {}, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.levels || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to list levels:', error);
+                return [];
+            }
+        },
+        currentLevel: async (_, __, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_current_level', {}, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                return null;
+            }
+            catch (error) {
+                console.error('Failed to get current level:', error);
+                return null;
+            }
+        },
+        materials: async (_, args, context) => {
+            const { filter, pagination } = args;
+            try {
+                const materialFilter = { ...filter, class: 'MaterialInterface' };
+                const { assets, totalCount } = await listAssets(context.automationBridge, materialFilter, pagination);
+                const offset = pagination?.offset ?? 0;
+                const edges = assets.map((material, index) => ({
+                    node: material,
+                    cursor: Buffer.from(`${material.path}:${offset + index}`).toString('base64')
+                }));
+                return {
+                    edges,
+                    pageInfo: {
+                        hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
+                        hasPreviousPage: (pagination?.offset || 0) > 0,
+                        startCursor: edges.length > 0 ? edges[0].cursor : null,
+                        endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                    },
+                    totalCount
+                };
+            }
+            catch (error) {
+                console.error('Failed to list materials:', error);
+                return {
+                    edges: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                        startCursor: null,
+                        endCursor: null
+                    },
+                    totalCount: 0
+                };
+            }
+        },
+        sequences: async (_, args, context) => {
+            const { filter, pagination } = args;
+            try {
+                const sequenceFilter = { ...filter, class: 'LevelSequence' };
+                const { assets, totalCount } = await listAssets(context.automationBridge, sequenceFilter, pagination);
+                const offset = pagination?.offset ?? 0;
+                const edges = assets.map((sequence, index) => ({
+                    node: sequence,
+                    cursor: Buffer.from(`${sequence.path}:${offset + index}`).toString('base64')
+                }));
+                return {
+                    edges,
+                    pageInfo: {
+                        hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
+                        hasPreviousPage: (pagination?.offset || 0) > 0,
+                        startCursor: edges.length > 0 ? edges[0].cursor : null,
+                        endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                    },
+                    totalCount
+                };
+            }
+            catch (error) {
+                console.error('Failed to list sequences:', error);
+                return {
+                    edges: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                        startCursor: null,
+                        endCursor: null
+                    },
+                    totalCount: 0
+                };
+            }
+        },
+        worldPartitionCells: async (_, __, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('manage_world_partition', { subAction: 'get_cells' }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.cells || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to list world partition cells:', error);
+                return [];
+            }
+        },
+        niagaraSystems: async (_, args, context) => {
+            const { filter, pagination } = args;
+            try {
+                const niagaraFilter = { ...filter, class: 'NiagaraSystem' };
+                const { assets, totalCount } = await listAssets(context.automationBridge, niagaraFilter, pagination);
+                const offset = pagination?.offset ?? 0;
+                const edges = assets.map((asset, index) => ({
+                    node: {
+                        ...asset,
+                        emitters: [],
+                        parameters: []
+                    },
+                    cursor: Buffer.from(`${asset.path}:${offset + index}`).toString('base64')
+                }));
+                return {
+                    edges,
+                    pageInfo: {
+                        hasNextPage: (pagination?.offset || 0) + assets.length < totalCount,
+                        hasPreviousPage: (pagination?.offset || 0) > 0,
+                        startCursor: edges.length > 0 ? edges[0].cursor : null,
+                        endCursor: edges.length > 0 ? edges[edges.length - 1].cursor : null
+                    },
+                    totalCount
+                };
+            }
+            catch (error) {
+                console.error('Failed to list niagara systems:', error);
+                return {
+                    edges: [],
+                    pageInfo: {
+                        hasNextPage: false,
+                        hasPreviousPage: false,
+                        startCursor: null,
+                        endCursor: null
+                    },
+                    totalCount: 0
+                };
+            }
+        },
+        niagaraSystem: async (_, { path }, context) => {
+            try {
+                const asset = await context.automationBridge.sendAutomationRequest('get_asset', { assetPath: path }, { timeoutMs: 10000 });
+                if (asset.success && asset.result && asset.result.class === 'NiagaraSystem') {
+                    return {
+                        ...asset.result,
+                        emitters: [],
+                        parameters: []
+                    };
+                }
+                return null;
+            }
+            catch (error) {
+                console.error('Failed to get niagara system:', error);
+                return null;
+            }
+        },
+        search: async (_, { query, type }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('search', {
+                    query,
+                    type: type || 'ALL'
+                }, { timeoutMs: 30000 });
+                if (response.success && response.result) {
+                    return response.result.results || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to search:', error);
+                return [];
+            }
+        }
+    },
+    Mutation: {
+        duplicateAsset: async (_, { path, newName }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('duplicate_asset', {
+                    assetPath: path,
+                    newName
+                }, { timeoutMs: 60000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to duplicate asset');
+            }
+            catch (error) {
+                console.error('Failed to duplicate asset:', error);
+                throw error;
+            }
+        },
+        moveAsset: async (_, { path, newPath }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('move_asset', {
+                    assetPath: path,
+                    destinationPath: newPath
+                }, { timeoutMs: 60000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to move asset');
+            }
+            catch (error) {
+                console.error('Failed to move asset:', error);
+                throw error;
+            }
+        },
+        deleteAsset: async (_, { path }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('delete_asset', {
+                    assetPath: path
+                }, { timeoutMs: 30000 });
+                return response.success || false;
+            }
+            catch (error) {
+                console.error('Failed to delete asset:', error);
+                return false;
+            }
+        },
+        spawnActor: async (_, { input }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('spawn_actor', input, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to spawn actor');
+            }
+            catch (error) {
+                console.error('Failed to spawn actor:', error);
+                throw error;
+            }
+        },
+        deleteActor: async (_, { name }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('delete_actor', {
+                    actorName: name
+                }, { timeoutMs: 10000 });
+                return response.success || false;
+            }
+            catch (error) {
+                console.error('Failed to delete actor:', error);
+                return false;
+            }
+        },
+        setActorTransform: async (_, { name, transform }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('set_actor_transform', {
+                    actorName: name,
+                    transform
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to set actor transform');
+            }
+            catch (error) {
+                console.error('Failed to set actor transform:', error);
+                throw error;
+            }
+        },
+        createBlueprint: async (_, { input }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('create_blueprint', input, { timeoutMs: 60000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to create blueprint');
+            }
+            catch (error) {
+                console.error('Failed to create blueprint:', error);
+                throw error;
+            }
+        },
+        addVariableToBlueprint: async (_, { path, input }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('add_variable_to_blueprint', {
+                    blueprintPath: path,
+                    ...input
+                }, { timeoutMs: 30000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to add variable to blueprint');
+            }
+            catch (error) {
+                console.error('Failed to add variable to blueprint:', error);
+                throw error;
+            }
+        },
+        addFunctionToBlueprint: async (_, { path, input }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('add_function_to_blueprint', {
+                    blueprintPath: path,
+                    ...input
+                }, { timeoutMs: 30000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to add function to blueprint');
+            }
+            catch (error) {
+                console.error('Failed to add function to blueprint:', error);
+                throw error;
+            }
+        },
+        loadLevel: async (_, { path }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('load_level', {
+                    levelPath: path
+                }, { timeoutMs: 30000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to load level');
+            }
+            catch (error) {
+                console.error('Failed to load level:', error);
+                throw error;
+            }
+        },
+        saveLevel: async (_, { path }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('save_level', {
+                    levelPath: path
+                }, { timeoutMs: 30000 });
+                return response.success || false;
+            }
+            catch (error) {
+                console.error('Failed to save level:', error);
+                return false;
+            }
+        },
+        createMaterialInstance: async (_, { parentPath, name, parameters }, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('create_material_instance', {
+                    parentMaterialPath: parentPath,
+                    instanceName: name,
+                    parameters: parameters || {}
+                }, { timeoutMs: 30000 });
+                if (response.success && response.result) {
+                    return response.result;
+                }
+                throw new Error(response.error || 'Failed to create material instance');
+            }
+            catch (error) {
+                console.error('Failed to create material instance:', error);
+                throw error;
+            }
+        }
+    },
+    Asset: {
+        dependencies: async (parent, _, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_asset_dependencies', {
+                    assetPath: parent.path
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.dependencies || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to get asset dependencies:', error);
+                return [];
+            }
+        },
+        dependents: async (parent, _, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_asset_dependents', {
+                    assetPath: parent.path
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.dependents || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to get asset dependents:', error);
+                return [];
+            }
+        }
+    },
+    Actor: {
+        properties: async (parent, _, context) => {
+            return await getActorProperties(context.bridge, parent.name);
+        },
+        components: async (parent, _, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_actor_components', {
+                    actorName: parent.name
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.components || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to get actor components:', error);
+                return [];
+            }
+        }
+    },
+    Blueprint: {
+        variables: async (parent, _args, _context) => {
+            return parent.variables || [];
+        },
+        functions: async (parent, _args, _context) => {
+            return parent.functions || [];
+        },
+        events: async (parent, _args, _context) => {
+            return parent.events || [];
+        },
+        components: async (parent, _args, _context) => {
+            return parent.components || [];
+        }
+    },
+    Material: {
+        parameters: async (parent, _, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_material_parameters', {
+                    materialPath: parent.path
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.parameters || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to get material parameters:', error);
+                return [];
+            }
+        }
+    },
+    Sequence: {
+        tracks: async (parent, _, context) => {
+            try {
+                const response = await context.automationBridge.sendAutomationRequest('get_sequence_tracks', {
+                    sequencePath: parent.path
+                }, { timeoutMs: 10000 });
+                if (response.success && response.result) {
+                    return response.result.tracks || [];
+                }
+                return [];
+            }
+            catch (error) {
+                console.error('Failed to get sequence tracks:', error);
+                return [];
+            }
+        }
+    }
+};
+//# sourceMappingURL=resolvers.js.map