unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/automation/message-handler.js

@@ -92,7 +92,7 @@ export class MessageHandler {
                     const synthetic = {
                         type: 'automation_response',
                         requestId: reqId,
-                        success: evtSuccess !== undefined ? evtSuccess : (baseSuccess !== undefined ? baseSuccess : undefined),
+                        success: evtSuccess !== undefined ? evtSuccess : baseSuccess,
                         message: typeof evt.result?.message === 'string' ? evt.result.message : (typeof evt.message === 'string' ? evt.message : FStringSafe(evt.event)),
                         error: typeof evt.result?.error === 'string' ? evt.result.error : undefined,
                         result: evt.result ?? evt.payload ?? undefined
@@ -113,8 +113,9 @@ export class MessageHandler {
             const expected = (expectedAction || '').toString().toLowerCase();
             const echoed = (() => {
                 const r = response;
-                const candidate = (typeof r.action === 'string' && r.action) || (typeof r.result?.action === 'string' && r.result.action);
-                return candidate;
+                const resultObj = response.result;
+                const candidate = (typeof r.action === 'string' && r.action) || (typeof resultObj?.action === 'string' && resultObj.action);
+                return candidate || undefined;
             })();
             if (expected && echoed && typeof echoed === 'string') {
                 const got = echoed.toLowerCase();
@@ -141,7 +142,7 @@ export class MessageHandler {
             }
         }
         catch (e) {
-            this.log.debug('enforceActionMatch check skipped', e);
+            this.log.debug('enforceActionMatch check skipped', e instanceof Error ? e.message : String(e));
         }
         return response;
     }

package/dist/automation/request-tracker.d.ts

@@ -3,7 +3,11 @@ export declare class RequestTracker {
     private maxPendingRequests;
     private pendingRequests;
     private coalescedRequests;
+    private lastRequestSentAt?;
     constructor(maxPendingRequests: number);
+    getMaxPendingRequests(): number;
+    getLastRequestSentAt(): Date | undefined;
+    updateLastRequestSentAt(): void;
     createRequest(action: string, payload: Record<string, unknown>, timeoutMs: number): {
         requestId: string;
         promise: Promise<AutomationBridgeResponseMessage>;

package/dist/automation/request-tracker.js

@@ -1,18 +1,26 @@
 import { randomUUID, createHash } from 'node:crypto';
-const WAIT_FOR_EVENT_ACTIONS = new Set([]);
 export class RequestTracker {
     maxPendingRequests;
     pendingRequests = new Map();
     coalescedRequests = new Map();
+    lastRequestSentAt;
     constructor(maxPendingRequests) {
         this.maxPendingRequests = maxPendingRequests;
     }
+    getMaxPendingRequests() {
+        return this.maxPendingRequests;
+    }
+    getLastRequestSentAt() {
+        return this.lastRequestSentAt;
+    }
+    updateLastRequestSentAt() {
+        this.lastRequestSentAt = new Date();
+    }
     createRequest(action, payload, timeoutMs) {
         if (this.pendingRequests.size >= this.maxPendingRequests) {
             throw new Error(`Max pending requests limit reached (${this.maxPendingRequests})`);
         }
         const requestId = randomUUID();
-        const waitForEvent = WAIT_FOR_EVENT_ACTIONS.has(action);
         const promise = new Promise((resolve, reject) => {
             const timeout = setTimeout(() => {
                 if (this.pendingRequests.has(requestId)) {
@@ -27,7 +35,7 @@ export class RequestTracker {
                 action,
                 payload,
                 requestedAt: new Date(),
-                waitForEvent,
+                waitForEvent: false,
                 eventTimeoutMs: timeoutMs
             });
         });

package/dist/config.d.ts

@@ -14,7 +14,6 @@ export declare const EnvSchema: z.ZodObject<{
     MCP_ROUTE_STDOUT_LOGS: z.ZodPipe<z.ZodTransform<boolean, unknown>, z.ZodDefault<z.ZodBoolean>>;
     UE_PROJECT_PATH: z.ZodOptional<z.ZodString>;
     UE_EDITOR_EXE: z.ZodOptional<z.ZodString>;
-    UE_SCREENSHOT_DIR: z.ZodOptional<z.ZodString>;
     MCP_AUTOMATION_PORT: z.ZodPipe<z.ZodTransform<number, unknown>, z.ZodDefault<z.ZodNumber>>;
     MCP_AUTOMATION_HOST: z.ZodDefault<z.ZodString>;
     MCP_AUTOMATION_CLIENT_MODE: z.ZodPipe<z.ZodTransform<boolean, unknown>, z.ZodDefault<z.ZodBoolean>>;

package/dist/config.js

@@ -34,7 +34,6 @@ export const EnvSchema = z.object({
     MCP_ROUTE_STDOUT_LOGS: z.preprocess(stringToBoolean, z.boolean().default(true)),
     UE_PROJECT_PATH: z.string().optional(),
     UE_EDITOR_EXE: z.string().optional(),
-    UE_SCREENSHOT_DIR: z.string().optional(),
     MCP_AUTOMATION_PORT: z.preprocess((v) => stringToNumber(v, 8091), z.number().default(8091)),
     MCP_AUTOMATION_HOST: z.string().default('127.0.0.1'),
     MCP_AUTOMATION_CLIENT_MODE: z.preprocess(stringToBoolean, z.boolean().default(false)),

package/dist/constants.d.ts

@@ -9,4 +9,8 @@ export declare const DEFAULT_TIME_OF_DAY = 9;
 export declare const DEFAULT_SUN_INTENSITY = 10000;
 export declare const DEFAULT_SKYLIGHT_INTENSITY = 1;
 export declare const DEFAULT_SCREENSHOT_RESOLUTION = "1920x1080";
+export declare const DEFAULT_OPERATION_TIMEOUT_MS = 30000;
+export declare const DEFAULT_ASSET_OP_TIMEOUT_MS = 60000;
+export declare const EXTENDED_ASSET_OP_TIMEOUT_MS = 120000;
+export declare const LONG_RUNNING_OP_TIMEOUT_MS = 300000;
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -9,4 +9,8 @@ export const DEFAULT_TIME_OF_DAY = 9;
 export const DEFAULT_SUN_INTENSITY = 10000;
 export const DEFAULT_SKYLIGHT_INTENSITY = 1;
 export const DEFAULT_SCREENSHOT_RESOLUTION = '1920x1080';
+export const DEFAULT_OPERATION_TIMEOUT_MS = 30000;
+export const DEFAULT_ASSET_OP_TIMEOUT_MS = 60000;
+export const EXTENDED_ASSET_OP_TIMEOUT_MS = 120000;
+export const LONG_RUNNING_OP_TIMEOUT_MS = 300000;
 //# sourceMappingURL=constants.js.map

package/dist/graphql/loaders.d.ts

@@ -0,0 +1,64 @@
+import DataLoader from 'dataloader';
+import type { AutomationBridge } from '../automation/index.js';
+export interface Actor {
+    name: string;
+    label?: string;
+    class?: string;
+    path?: string;
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    tags?: string[];
+}
+export interface Asset {
+    name: string;
+    path: string;
+    class?: string;
+    packagePath?: string;
+    size?: number;
+}
+export interface Blueprint {
+    name: string;
+    path: string;
+    parentClass?: string;
+    variables?: Array<{
+        name: string;
+        type: string;
+        defaultValue?: unknown;
+    }>;
+    functions?: Array<{
+        name: string;
+        parameters?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+    components?: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+export interface GraphQLLoaders {
+    actorLoader: DataLoader<string, Actor | null>;
+    assetLoader: DataLoader<string, Asset | null>;
+    blueprintLoader: DataLoader<string, Blueprint | null>;
+    actorComponentsLoader: DataLoader<string, Array<{
+        name: string;
+        type: string;
+    }> | null>;
+}
+export declare function createLoaders(automationBridge: AutomationBridge): GraphQLLoaders;
+export declare function clearLoaders(loaders: GraphQLLoaders): void;
+//# sourceMappingURL=loaders.d.ts.map

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