unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/dynamic-handler-registry.js

@@ -0,0 +1,101 @@
+import { Logger } from '../utils/logger.js';
+import fs from 'fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const log = new Logger('DynamicHandlerRegistry');
+let registryLoaded = false;
+const loadedHandlers = [];
+async function loadRegistryIfNeeded() {
+    if (registryLoaded)
+        return;
+    registryLoaded = true;
+    const rootUrl = new URL('../..', import.meta.url);
+    const envPath = (process.env.MCP_HANDLER_REGISTRY || '').trim();
+    let configUrl = null;
+    try {
+        if (envPath) {
+            if (envPath.startsWith('file:')) {
+                configUrl = new URL(envPath);
+            }
+            else if (path.isAbsolute(envPath)) {
+                configUrl = pathToFileURL(envPath);
+            }
+            else {
+                configUrl = new URL(envPath, rootUrl);
+            }
+        }
+        else {
+            configUrl = new URL('handler-registry.json', rootUrl);
+        }
+        let jsonText;
+        try {
+            jsonText = await fs.readFile(configUrl, 'utf8');
+        }
+        catch (err) {
+            if (err && (err.code === 'ENOENT' || err.code === 'ERR_MODULE_NOT_FOUND')) {
+                log.debug(`Handler registry not found at ${configUrl.href}; dynamic handlers disabled.`);
+                return;
+            }
+            log.warn(`Failed to read handler registry from ${configUrl.href}:`, err);
+            return;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(jsonText);
+        }
+        catch (err) {
+            log.warn(`Invalid JSON in handler registry at ${configUrl.href}:`, err);
+            return;
+        }
+        if (!raw.handlers || !Array.isArray(raw.handlers)) {
+            log.debug('Handler registry contains no handlers.');
+            return;
+        }
+        for (const entry of raw.handlers) {
+            if (!entry || typeof entry.tool !== 'string' || typeof entry.module !== 'string') {
+                continue;
+            }
+            try {
+                const modUrl = new URL(entry.module, rootUrl);
+                const mod = await import(modUrl.href);
+                const exportName = entry.function && entry.function.trim().length > 0
+                    ? entry.function.trim()
+                    : 'default';
+                const fnExport = mod[exportName];
+                if (typeof fnExport !== 'function') {
+                    log.warn(`Dynamic handler module ${modUrl.href} for tool '${entry.tool}' does not export a callable '${exportName}'.`);
+                    continue;
+                }
+                const wrapped = fnExport;
+                loadedHandlers.push({
+                    tool: entry.tool,
+                    actions: Array.isArray(entry.actions) ? entry.actions.slice() : undefined,
+                    fn: wrapped
+                });
+                log.info(`Registered dynamic handler for tool '${entry.tool}' from ${modUrl.href}`);
+            }
+            catch (err) {
+                log.warn(`Failed to load dynamic handler for tool '${entry.tool}' from module spec '${entry.module}':`, err);
+            }
+        }
+    }
+    catch (err) {
+        log.warn('Unexpected error while loading handler registry:', err);
+    }
+}
+export async function getDynamicHandlerForTool(toolName, action) {
+    await loadRegistryIfNeeded();
+    if (!loadedHandlers.length)
+        return null;
+    const name = toolName;
+    const act = action;
+    for (const handler of loadedHandlers) {
+        if (handler.tool !== name)
+            continue;
+        if (handler.actions && act && !handler.actions.includes(act))
+            continue;
+        return handler.fn;
+    }
+    return null;
+}
+//# sourceMappingURL=dynamic-handler-registry.js.map

package/dist/tools/editor.d.ts

@@ -1,25 +1,27 @@
-import { UnrealBridge } from '../unreal-bridge.js';
-export declare class EditorTools {
-    private bridge;
-    constructor(bridge: UnrealBridge);
+import { BaseTool } from './base-tool.js';
+import { IEditorTools } from '../types/tool-interfaces.js';
+export declare class EditorTools extends BaseTool implements IEditorTools {
+    private cameraBookmarks;
+    private editorPreferences;
+    private activeRecording?;
     isInPIE(): Promise<boolean>;
     ensureNotInPIE(): Promise<void>;
-    playInEditor(): Promise<{
+    playInEditor(timeoutMs?: number): Promise<{
         success: boolean;
-        message: string;
+        message: any;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
+        error: any;
         message?: undefined;
     }>;
     stopPlayInEditor(): Promise<{
         success: boolean;
-        message: string;
+        message: any;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
+        error: any;
         message?: undefined;
     }>;
     pausePlayInEditor(): Promise<{
@@ -44,18 +46,12 @@ export declare class EditorTools {
         success: boolean;
         message: string;
         error?: undefined;
-        details?: undefined;
     } | {
         success: boolean;
         error: string;
-        details: string | undefined;
         message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        message?: undefined;
-        details?: undefined;
     }>;
+    private getViewportCameraInfo;
     setViewportCamera(location?: {
         x: number;
         y: number;
@@ -66,12 +62,24 @@ export declare class EditorTools {
         roll: number;
     } | [number, number, number] | null | undefined): Promise<{
         success: boolean;
-        message: string;
+        message: any;
+        location: [number, number, number] | {
+            x: number;
+            y: number;
+            z: number;
+        } | null | undefined;
+        rotation: [number, number, number] | {
+            pitch: number;
+            yaw: number;
+            roll: number;
+        } | null | undefined;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
+        error: any;
         message?: undefined;
+        location?: undefined;
+        rotation?: undefined;
     }>;
     setCameraSpeed(speed: number): Promise<{
         success: boolean;
@@ -91,5 +99,118 @@ export declare class EditorTools {
         error: string;
         message?: undefined;
     }>;
+    takeScreenshot(filename?: string, resolution?: string): Promise<{
+        success: boolean;
+        error: string;
+        message?: undefined;
+        filename?: undefined;
+        command?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        filename: string;
+        command: string;
+        error?: undefined;
+    }>;
+    resumePlayInEditor(): Promise<{
+        success: boolean;
+        message: string;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+    }>;
+    stepPIEFrame(steps?: number): Promise<{
+        success: boolean;
+        message: string;
+        steps: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        steps?: undefined;
+    }>;
+    startRecording(options?: {
+        filename?: string;
+        frameRate?: number;
+        durationSeconds?: number;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        success: true;
+        message: string;
+        recording: {
+            name: string | undefined;
+            startedAt: number;
+            options: Record<string, unknown> | undefined;
+        };
+    }>;
+    stopRecording(): Promise<{
+        success: true;
+        message: string;
+        recording?: undefined;
+    } | {
+        success: true;
+        message: string;
+        recording: {
+            name?: string;
+            options?: Record<string, unknown>;
+            startedAt: number;
+        };
+    }>;
+    createCameraBookmark(name: string): Promise<{
+        success: false;
+        error: string;
+        message?: undefined;
+        bookmark?: undefined;
+    } | {
+        success: true;
+        message: string;
+        bookmark: {
+            name: string;
+            location: [number, number, number];
+            rotation: [number, number, number];
+        };
+        error?: undefined;
+    }>;
+    jumpToCameraBookmark(name: string): Promise<{
+        success: false;
+        error: string;
+        message?: undefined;
+    } | {
+        success: true;
+        message: string;
+        error?: undefined;
+    }>;
+    setEditorPreferences(category: string | undefined, preferences: Record<string, unknown>): Promise<{
+        success: true;
+        message: string;
+        preferences: Record<string, unknown> | undefined;
+    }>;
+    setViewportResolution(width: number, height: number): Promise<{
+        success: boolean;
+        message: string;
+        width: number;
+        height: number;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: string;
+        message?: undefined;
+        width?: undefined;
+        height?: undefined;
+    }>;
+    executeConsoleCommand(command: string): Promise<{
+        success: boolean;
+        error: string;
+        message?: undefined;
+        output?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        output: any;
+        error?: undefined;
+    }>;
 }
 //# sourceMappingURL=editor.d.ts.map