unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/graphql/resolvers.js

@@ -1,776 +0,0 @@
-import { sanitizePath } from '../utils/path-security.js';
-import { sanitizeAssetName, sanitizePath as normalizeAndSanitizePath } from '../utils/validation.js';
-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' && ast.fields) {
-                const result = {};
-                ast.fields.forEach((field) => {
-                    result[field.name.value] = field.value.value;
-                });
-                return result;
-            }
-            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' && ast.fields) {
-                const result = {};
-                ast.fields.forEach((field) => {
-                    result[field.name.value] = field.value.value;
-                });
-                return result;
-            }
-            return null;
-        }
-    },
-    Transform: {
-        serialize: (value) => value,
-        parseValue: (value) => value,
-        parseLiteral: (ast) => {
-            if (ast.kind === 'ObjectValue' && ast.fields) {
-                const result = {};
-                ast.fields.forEach((field) => {
-                    if (field.value.kind === 'ObjectValue' && field.value.fields) {
-                        result[field.name.value] = {};
-                        const nestedObj = result[field.name.value];
-                        field.value.fields.forEach((f) => {
-                            nestedObj[f.name.value] = f.value.value;
-                        });
-                    }
-                    else {
-                        result[field.name.value] = field.value.value;
-                    }
-                });
-                return result;
-            }
-            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':
-                    if (ast.fields) {
-                        const result = {};
-                        ast.fields.forEach((field) => {
-                            result[field.name.value] = scalarResolvers.JSON.parseLiteral(field.value);
-                        });
-                        return result;
-                    }
-                    return {};
-                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 safeFilter = { ...filter };
-        if (safeFilter.pathStartsWith) {
-            safeFilter.pathStartsWith = normalizeAndSanitizePath(safeFilter.pathStartsWith);
-        }
-        const response = await automationBridge.sendAutomationRequest('list_assets', {
-            filter: safeFilter,
-            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) {
-        log.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(sanitizePath(path));
-            }
-            catch (error) {
-                log.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) {
-                log.error('Failed to get actor:', error);
-                return null;
-            }
-        },
-        blueprints: async (_, args, context) => {
-            const { filter, pagination } = args;
-            try {
-                const safeFilter = { ...filter };
-                if (safeFilter.pathStartsWith) {
-                    safeFilter.pathStartsWith = normalizeAndSanitizePath(safeFilter.pathStartsWith);
-                }
-                const response = await context.automationBridge.sendAutomationRequest('list_blueprints', {
-                    filter: safeFilter,
-                    pagination: pagination || { offset: 0, limit: 50 }
-                }, { timeoutMs: 30000 });
-                const resultObj = (response.result ?? {});
-                const blueprints = response.success && response.result
-                    ? (resultObj.blueprints || [])
-                    : [];
-                const edges = blueprints.map((blueprint, index) => ({
-                    node: blueprint,
-                    cursor: Buffer.from(`${blueprint.path}:${index}`).toString('base64')
-                }));
-                const totalCount = resultObj.totalCount || 0;
-                return {
-                    edges,
-                    pageInfo: {
-                        hasNextPage: (pagination?.offset || 0) + blueprints.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: blueprints.length
-                };
-            }
-            catch (error) {
-                log.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(sanitizePath(path));
-        },
-        levels: async (_, __, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('list_levels', {}, { timeoutMs: 10000 });
-                if (response.success && response.result) {
-                    const resultObj = response.result;
-                    return (resultObj.levels || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                log.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) {
-                log.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) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.cells || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                log.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: sanitizePath(path) }, { timeoutMs: 10000 });
-                const resultObj = (asset.result ?? {});
-                if (asset.success && asset.result && resultObj.class === 'NiagaraSystem') {
-                    return {
-                        ...resultObj,
-                        emitters: [],
-                        parameters: []
-                    };
-                }
-                return null;
-            }
-            catch (error) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.results || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.error('Failed to search:', error);
-                return [];
-            }
-        }
-    },
-    Mutation: {
-        duplicateAsset: async (_, { path, newName }, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('duplicate_asset', {
-                    assetPath: sanitizePath(path),
-                    newName: sanitizeAssetName(newName)
-                }, { timeoutMs: 60000 });
-                if (response.success && response.result) {
-                    return response.result;
-                }
-                throw new Error(response.error || 'Failed to duplicate asset');
-            }
-            catch (error) {
-                log.error('Failed to duplicate asset:', error);
-                throw error;
-            }
-        },
-        moveAsset: async (_, { path, newPath }, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('move_asset', {
-                    assetPath: sanitizePath(path),
-                    destinationPath: sanitizePath(newPath)
-                }, { timeoutMs: 60000 });
-                if (response.success && response.result) {
-                    return response.result;
-                }
-                throw new Error(response.error || 'Failed to move asset');
-            }
-            catch (error) {
-                log.error('Failed to move asset:', error);
-                throw error;
-            }
-        },
-        deleteAsset: async (_, { path }, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('delete_asset', {
-                    assetPath: sanitizePath(path)
-                }, { timeoutMs: 30000 });
-                return response.success || false;
-            }
-            catch (error) {
-                log.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) {
-                log.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) {
-                log.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) {
-                log.error('Failed to set actor transform:', error);
-                throw error;
-            }
-        },
-        createBlueprint: async (_, { input }, context) => {
-            try {
-                const sanitizedInput = {
-                    ...input,
-                    name: sanitizeAssetName(input.name),
-                    path: input.path ? sanitizePath(input.path) : undefined
-                };
-                const response = await context.automationBridge.sendAutomationRequest('create_blueprint', sanitizedInput, { timeoutMs: 60000 });
-                if (response.success && response.result) {
-                    return response.result;
-                }
-                throw new Error(response.error || 'Failed to create blueprint');
-            }
-            catch (error) {
-                log.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: sanitizePath(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) {
-                log.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: sanitizePath(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) {
-                log.error('Failed to add function to blueprint:', error);
-                throw error;
-            }
-        },
-        loadLevel: async (_, { path }, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('load_level', {
-                    levelPath: sanitizePath(path)
-                }, { timeoutMs: 30000 });
-                if (response.success && response.result) {
-                    return response.result;
-                }
-                throw new Error(response.error || 'Failed to load level');
-            }
-            catch (error) {
-                log.error('Failed to load level:', error);
-                throw error;
-            }
-        },
-        saveLevel: async (_, { path }, context) => {
-            try {
-                const response = await context.automationBridge.sendAutomationRequest('save_level', {
-                    levelPath: path ? sanitizePath(path) : undefined
-                }, { timeoutMs: 30000 });
-                return response.success || false;
-            }
-            catch (error) {
-                log.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: sanitizePath(parentPath),
-                    instanceName: sanitizeAssetName(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) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.dependencies || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.dependents || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.components || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.parameters || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.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) {
-                    const resultObj = response.result;
-                    return (resultObj.tracks || []);
-                }
-                return [];
-            }
-            catch (error) {
-                log.error('Failed to get sequence tracks:', error);
-                return [];
-            }
-        }
-    }
-};
-//# sourceMappingURL=resolvers.js.map