unreal-engine-mcp-server 0.5.0 → 0.5.1

package/dist/graphql/loaders.js

@@ -0,0 +1,117 @@
+import DataLoader from 'dataloader';
+import { Logger } from '../utils/logger.js';
+const log = new Logger('GraphQL:Loaders');
+export function createLoaders(automationBridge) {
+    return {
+        actorLoader: new DataLoader(async (names) => {
+            log.debug(`Batching actor fetch for ${names.length} actors`);
+            try {
+                const result = await automationBridge.sendAutomationRequest('control_actor', {
+                    action: 'batch_get',
+                    actorNames: [...names]
+                });
+                if (result.success && result.actors) {
+                    return names.map(name => result.actors?.find(a => a.name === name || a.label === name) ?? null);
+                }
+            }
+            catch {
+                log.debug('Batch fetch not supported, falling back to individual fetches');
+            }
+            const results = await Promise.all(names.map(async (name) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('control_actor', {
+                        action: 'find_by_name',
+                        actorName: name
+                    });
+                    return result.success ? (result.actor ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 50
+        }),
+        assetLoader: new DataLoader(async (paths) => {
+            log.debug(`Batching asset fetch for ${paths.length} assets`);
+            try {
+                const result = await automationBridge.sendAutomationRequest('manage_asset', {
+                    action: 'batch_get',
+                    assetPaths: [...paths]
+                });
+                if (result.success && result.assets) {
+                    return paths.map(path => result.assets?.find(a => a.path === path) ?? null);
+                }
+            }
+            catch {
+                log.debug('Batch asset fetch not supported');
+            }
+            const results = await Promise.all(paths.map(async (path) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('manage_asset', {
+                        action: 'exists',
+                        assetPath: path
+                    });
+                    if (result.success && result.exists) {
+                        return result.asset ?? { name: path.split('/').pop() || '', path };
+                    }
+                    return null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 100
+        }),
+        blueprintLoader: new DataLoader(async (paths) => {
+            log.debug(`Batching blueprint fetch for ${paths.length} blueprints`);
+            const results = await Promise.all(paths.map(async (path) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('manage_blueprint', {
+                        action: 'get_blueprint',
+                        blueprintPath: path
+                    });
+                    return result.success ? (result.blueprint ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 20
+        }),
+        actorComponentsLoader: new DataLoader(async (actorNames) => {
+            log.debug(`Batching component fetch for ${actorNames.length} actors`);
+            const results = await Promise.all(actorNames.map(async (actorName) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('control_actor', {
+                        action: 'get_components',
+                        actorName
+                    });
+                    return result.success ? (result.components ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 30
+        })
+    };
+}
+export function clearLoaders(loaders) {
+    loaders.actorLoader.clearAll();
+    loaders.assetLoader.clearAll();
+    loaders.blueprintLoader.clearAll();
+    loaders.actorComponentsLoader.clearAll();
+}
+//# sourceMappingURL=loaders.js.map

package/dist/graphql/resolvers.d.ts

@@ -100,7 +100,7 @@ export declare const resolvers: {
         }>;
         asset: (_: any, { path }: {
             path: string;
-        }, context: GraphQLContext) => Promise<{} | null>;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Asset | null>;
         actors: (_: any, args: any, context: GraphQLContext) => Promise<{
             edges: {
                 node: Actor;
@@ -116,7 +116,7 @@ export declare const resolvers: {
         }>;
         actor: (_: any, { name }: {
             name: string;
-        }, context: GraphQLContext) => Promise<Actor | null>;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Actor | null>;
         blueprints: (_: any, args: any, context: GraphQLContext) => Promise<{
             edges: {
                 node: Blueprint;
@@ -141,7 +141,7 @@ export declare const resolvers: {
         }>;
         blueprint: (_: any, { path }: {
             path: string;
-        }, context: GraphQLContext) => Promise<Blueprint | null>;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Blueprint | null>;
         levels: (_: any, __: any, context: GraphQLContext) => Promise<any>;
         currentLevel: (_: any, __: any, context: GraphQLContext) => Promise<{} | null>;
         materials: (_: any, args: any, context: GraphQLContext) => Promise<{

package/dist/graphql/resolvers.js

@@ -87,6 +87,24 @@ export const scalarResolvers = {
         }
     }
 };
+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) {
@@ -96,7 +114,7 @@ function logAutomationFailure(source, response) {
         if (errorText.length === 0) {
             return;
         }
-        console.error(`[GraphQL] ${source} automation failure:`, errorText);
+        log.error(`${source} automation failure:`, errorText);
     }
     catch {
     }
@@ -111,7 +129,7 @@ async function getActorProperties(bridge, actorName) {
         return result.success ? result.value || {} : {};
     }
     catch (error) {
-        console.error('Failed to get actor properties:', error);
+        log.error('Failed to get actor properties:', error);
         return {};
     }
 }
@@ -129,12 +147,12 @@ async function listAssets(automationBridge, filter, pagination) {
             };
         }
         logAutomationFailure('list_assets', response);
-        console.error('Failed to list assets:', response);
+        log.warn('Failed to list assets - returning empty set');
         return { assets: [], totalCount: 0 };
     }
     catch (error) {
-        console.error('Failed to list assets:', error);
-        return { assets: [], totalCount: 0 };
+        log.error('Failed to list assets:', error);
+        throw createResolverError('listAssets', error);
     }
 }
 async function listActors(automationBridge, filter) {
@@ -156,22 +174,6 @@ async function listActors(automationBridge, filter) {
         return { actors: [] };
     }
 }
-async function getBlueprint(automationBridge, blueprintPath) {
-    try {
-        const response = await automationBridge.sendAutomationRequest('get_blueprint', {
-            blueprintPath
-        }, { timeoutMs: 30000 });
-        if (response.success && response.result) {
-            return response.result;
-        }
-        logAutomationFailure('get_blueprint', response);
-        return null;
-    }
-    catch (error) {
-        console.error('Failed to get blueprint:', error);
-        return null;
-    }
-}
 export const resolvers = {
     Query: {
         assets: async (_, args, context) => {
@@ -194,11 +196,10 @@ export const resolvers = {
         },
         asset: async (_, { path }, context) => {
             try {
-                const response = await context.automationBridge.sendAutomationRequest('get_asset', { assetPath: path }, { timeoutMs: 10000 });
-                if (response.success && response.result) {
-                    return response.result;
+                if (!context.loaders) {
+                    throw new Error('Loaders not initialized');
                 }
-                return null;
+                return await context.loaders.assetLoader.load(path);
             }
             catch (error) {
                 console.error('Failed to get asset:', error);
@@ -228,11 +229,10 @@ export const resolvers = {
         },
         actor: async (_, { name }, context) => {
             try {
-                const actors = await listActors(context.automationBridge, { tag: name });
-                if (actors.actors.length > 0) {
-                    return actors.actors[0];
+                if (!context.loaders) {
+                    throw new Error('Loaders not initialized');
                 }
-                return null;
+                return await context.loaders.actorLoader.load(name);
             }
             catch (error) {
                 console.error('Failed to get actor:', error);
@@ -279,7 +279,10 @@ export const resolvers = {
             }
         },
         blueprint: async (_, { path }, context) => {
-            return await getBlueprint(context.automationBridge, path);
+            if (!context.loaders) {
+                throw new Error('Loaders not initialized');
+            }
+            return await context.loaders.blueprintLoader.load(path);
         },
         levels: async (_, __, context) => {
             try {

package/dist/graphql/server.js

@@ -2,6 +2,7 @@ import { createYoga } from 'graphql-yoga';
 import { createServer } from 'http';
 import { Logger } from '../utils/logger.js';
 import { createGraphQLSchema } from './schema.js';
+import { createLoaders } from './loaders.js';
 export class GraphQLServer {
     log = new Logger('GraphQLServer');
     server = null;
@@ -40,7 +41,8 @@ export class GraphQLServer {
                 },
                 context: () => ({
                     bridge: this.bridge,
-                    automationBridge: this.automationBridge
+                    automationBridge: this.automationBridge,
+                    loaders: createLoaders(this.automationBridge)
                 }),
                 logging: {
                     debug: (...args) => this.log.debug('[GraphQL]', ...args),

package/dist/graphql/types.d.ts

@@ -1,7 +1,9 @@
 import type { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
+import type { GraphQLLoaders } from './loaders.js';
 export interface GraphQLContext {
     bridge: UnrealBridge;
     automationBridge: AutomationBridge;
+    loaders?: GraphQLLoaders;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { UnrealBridge } from './unreal-bridge.js';
 import { AutomationBridge } from './automation/index.js';
 import { z } from 'zod';
+import { GraphQLServer } from './graphql/server.js';
 export declare function createServer(): {
     server: Server<{
         method: string;
@@ -39,6 +40,7 @@ export declare function createServer(): {
     }>;
     bridge: UnrealBridge;
     automationBridge: AutomationBridge;
+    graphqlServer: GraphQLServer;
 };
 export declare const configSchema: z.ZodObject<{
     logLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<{

package/dist/index.js

@@ -12,6 +12,7 @@ import { HealthMonitor } from './services/health-monitor.js';
 import { ServerSetup } from './server-setup.js';
 import { startMetricsServer } from './services/metrics-server.js';
 import { config } from './config.js';
+import { GraphQLServer } from './graphql/server.js';
 const require = createRequire(import.meta.url);
 const packageInfo = (() => {
     try {
@@ -81,6 +82,10 @@ export function createServer() {
         log.error('Automation bridge error', error);
     });
     startMetricsServer({ healthMonitor, automationBridge, logger: log });
+    const graphqlServer = new GraphQLServer(bridge, automationBridge);
+    graphqlServer.start().catch((error) => {
+        log.warn('GraphQL server failed to start:', error);
+    });
     log.debug('Initializing WebAssembly integration...');
     initializeWASM().then(() => {
         log.info('✅ WebAssembly integration initialized (JSON parsing and math operations)');
@@ -109,7 +114,7 @@ export function createServer() {
     });
     const serverSetup = new ServerSetup(server, bridge, automationBridge, log, healthMonitor);
     serverSetup.setup();
-    return { server, bridge, automationBridge };
+    return { server, bridge, automationBridge, graphqlServer };
 }
 export const configSchema = z.object({
     logLevel: z.enum(['debug', 'info', 'warn', 'error']).optional().default('info').describe('Runtime log level'),
@@ -131,7 +136,7 @@ export default function createServerDefault({ config } = {}) {
     return server;
 }
 export async function startStdioServer() {
-    const { server, automationBridge } = createServer();
+    const { server, automationBridge, graphqlServer } = createServer();
     const transport = new StdioServerTransport();
     let shuttingDown = false;
     const handleShutdown = async (signal) => {
@@ -147,6 +152,12 @@ export async function startStdioServer() {
         catch (error) {
             log.warn('Failed to stop automation bridge cleanly', error);
         }
+        try {
+            await graphqlServer.stop();
+        }
+        catch (error) {
+            log.warn('Failed to stop GraphQL server cleanly', error);
+        }
         try {
             if (typeof server.close === 'function') {
                 await server.close();

package/dist/server-setup.d.ts

@@ -16,6 +16,5 @@ export declare class ServerSetup {
     setup(): Promise<void>;
     private validateEnvironment;
     private ensureConnectedOnDemand;
-    private registerPrompts;
 }
 //# sourceMappingURL=server-setup.d.ts.map

package/dist/server-setup.js

@@ -1,5 +1,3 @@
-import { ListPromptsRequestSchema, GetPromptRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { prompts } from './prompts/index.js';
 import { AssetResources } from './resources/assets.js';
 import { ActorResources } from './resources/actors.js';
 import { LevelResources } from './resources/levels.js';
@@ -32,7 +30,6 @@ export class ServerSetup {
         resourceRegistry.register();
         const toolRegistry = new ToolRegistry(this.server, this.bridge, this.automationBridge, this.logger, this.healthMonitor, this.assetResources, this.actorResources, this.levelResources, ensureConnected);
         toolRegistry.register();
-        this.registerPrompts();
     }
     validateEnvironment() {
         const projectPath = process.env.UE_PROJECT_PATH;
@@ -70,42 +67,5 @@ export class ServerSetup {
         }
         return ok;
     }
-    registerPrompts() {
-        this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-            return {
-                prompts: prompts.map(p => ({
-                    name: p.name,
-                    description: p.description,
-                    arguments: Object.entries(p.arguments || {}).map(([name, schema]) => {
-                        const meta = {};
-                        if (schema.type)
-                            meta.type = schema.type;
-                        if (schema.enum)
-                            meta.enum = schema.enum;
-                        if (schema.default !== undefined)
-                            meta.default = schema.default;
-                        return {
-                            name,
-                            description: schema.description,
-                            required: schema.required ?? false,
-                            ...(Object.keys(meta).length ? { _meta: meta } : {})
-                        };
-                    })
-                }))
-            };
-        });
-        this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-            const prompt = prompts.find(p => p.name === request.params.name);
-            if (!prompt) {
-                throw new Error(`Unknown prompt: ${request.params.name}`);
-            }
-            const args = (request.params.arguments || {});
-            const messages = prompt.build(args);
-            return {
-                description: prompt.description,
-                messages
-            };
-        });
-    }
 }
 //# sourceMappingURL=server-setup.js.map

package/dist/tools/actors.d.ts

@@ -22,7 +22,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
     delete(params: {
         actorName?: string;
         actorNames?: string[];
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     applyForce(params: {
         actorName: string;
         force: {
@@ -30,7 +30,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     private resolveActorClass;
     spawnBlueprint(params: {
         blueprintPath: string;
@@ -45,7 +45,7 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             yaw: number;
             roll: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     setTransform(params: {
         actorName: string;
         location?: {
@@ -63,26 +63,30 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
-    getTransform(actorName: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    getTransform(actorName: string): Promise<StandardActionResponse<any>>;
     setVisibility(params: {
         actorName: string;
         visible: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     addComponent(params: {
         actorName: string;
         componentType: string;
         componentName?: string;
         properties?: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     setComponentProperties(params: {
         actorName: string;
         componentName: string;
         properties: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     getComponents(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         components?: undefined;
         count?: undefined;
@@ -101,45 +105,49 @@ export declare class ActorTools extends BaseTool implements IActorTools {
             y: number;
             z: number;
         };
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     addTag(params: {
         actorName: string;
         tag: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     removeTag(params: {
         actorName: string;
         tag: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     findByTag(params: {
         tag: string;
         matchType?: string;
-    }): Promise<any>;
-    findByName(name: string): Promise<any>;
-    detach(actorName: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    findByName(name: string): Promise<StandardActionResponse<any>>;
+    detach(actorName: string): Promise<StandardActionResponse<any>>;
     attach(params: {
         childActor: string;
         parentActor: string;
-    }): Promise<any>;
-    deleteByTag(tag: string): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
+    deleteByTag(tag: string): Promise<StandardActionResponse<any>>;
     setBlueprintVariables(params: {
         actorName: string;
         variables: Record<string, unknown>;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     createSnapshot(params: {
         actorName: string;
         snapshotName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     restoreSnapshot(params: {
         actorName: string;
         snapshotName: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     exportActor(params: {
         actorName: string;
         destinationPath?: string;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse<any>>;
     getBoundingBox(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         boundingBox?: undefined;
     } | {
@@ -150,7 +158,11 @@ export declare class ActorTools extends BaseTool implements IActorTools {
     }>;
     getMetadata(actorName: string): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         metadata?: undefined;
     } | {
@@ -163,7 +175,11 @@ export declare class ActorTools extends BaseTool implements IActorTools {
         filter?: string;
     }): Promise<{
         success: boolean;
-        error: any;
+        error: string | {
+            [key: string]: unknown;
+            code?: string;
+            message: string;
+        };
         message?: undefined;
         actors?: undefined;
         count?: undefined;

package/dist/tools/actors.js

@@ -1,5 +1,6 @@
 import { ensureRotation, ensureVector3 } from '../utils/validation.js';
 import { BaseTool } from './base-tool.js';
+import { wasmIntegration } from '../wasm/index.js';
 export class ActorTools extends BaseTool {
     constructor(bridge) {
         super(bridge);
@@ -38,7 +39,9 @@ export class ActorTools extends BaseTool {
                 meshPath: params.meshPath
             }, timeoutMs ? { timeoutMs } : undefined);
             if (!response || !response.success) {
-                throw new Error(response?.error || response?.message || 'Failed to spawn actor');
+                const error = response?.error;
+                const errorMsg = typeof error === 'string' ? error : error?.message || response?.message || 'Failed to spawn actor';
+                throw new Error(errorMsg);
             }
             const data = response.data || {};
             const result = {
@@ -292,7 +295,10 @@ export class ActorTools extends BaseTool {
         }
         if (params.offset) {
             const offs = ensureVector3(params.offset, 'duplicate offset');
-            payload.offset = { x: offs[0], y: offs[1], z: offs[2] };
+            const origin = [0, 0, 0];
+            const calculatedOffset = wasmIntegration.vectorAdd(origin, offs);
+            console.error('[WASM] Using vectorAdd for duplicate offset calculation');
+            payload.offset = { x: calculatedOffset[0], y: calculatedOffset[1], z: calculatedOffset[2] };
         }
         return this.sendRequest('duplicate', payload, 'control_actor');
     }