unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/tools/environment.d.ts

@@ -0,0 +1,30 @@
+import { AutomationBridge } from '../automation/index.js';
+import { UnrealBridge } from '../unreal-bridge.js';
+import { IEnvironmentTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class EnvironmentTools implements IEnvironmentTools {
+    private automationBridge?;
+    constructor(_bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
+    private ensureAutomationBridge;
+    private getDefaultTimeOfDay;
+    private getDefaultSunIntensity;
+    private getDefaultSkylightIntensity;
+    private normalizeNumber;
+    private invoke;
+    setTimeOfDay(hour: unknown): Promise<StandardActionResponse>;
+    setSunIntensity(intensity: unknown): Promise<StandardActionResponse>;
+    setSkylightIntensity(intensity: unknown): Promise<StandardActionResponse>;
+    exportSnapshot(params: {
+        path?: unknown;
+        filename?: unknown;
+    }): Promise<StandardActionResponse>;
+    importSnapshot(params: {
+        path?: unknown;
+        filename?: unknown;
+    }): Promise<StandardActionResponse>;
+    cleanup(params?: {
+        names?: unknown;
+        name?: unknown;
+    }): Promise<StandardActionResponse>;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/tools/environment.js

@@ -0,0 +1,267 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_SKYLIGHT_INTENSITY, DEFAULT_SUN_INTENSITY, DEFAULT_TIME_OF_DAY } from '../constants.js';
+export class EnvironmentTools {
+    automationBridge;
+    constructor(_bridge, automationBridge) {
+        this.automationBridge = automationBridge;
+    }
+    setAutomationBridge(automationBridge) {
+        this.automationBridge = automationBridge;
+    }
+    ensureAutomationBridge() {
+        if (!this.automationBridge) {
+            throw new Error('AUTOMATION_BRIDGE_UNAVAILABLE');
+        }
+        return this.automationBridge;
+    }
+    getDefaultTimeOfDay() {
+        const raw = process.env.MCP_ENV_DEFAULT_TIME_OF_DAY;
+        if (raw !== undefined) {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed)) {
+                return parsed;
+            }
+        }
+        return DEFAULT_TIME_OF_DAY;
+    }
+    getDefaultSunIntensity() {
+        const raw = process.env.MCP_ENV_DEFAULT_SUN_INTENSITY;
+        if (raw !== undefined) {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed) && parsed >= 0) {
+                return parsed;
+            }
+        }
+        return DEFAULT_SUN_INTENSITY;
+    }
+    getDefaultSkylightIntensity() {
+        const raw = process.env.MCP_ENV_DEFAULT_SKYLIGHT_INTENSITY;
+        if (raw !== undefined) {
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed) && parsed >= 0) {
+                return parsed;
+            }
+        }
+        return DEFAULT_SKYLIGHT_INTENSITY;
+    }
+    normalizeNumber(value, field, fallback) {
+        if (value === undefined || value === null) {
+            return fallback;
+        }
+        const num = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(num)) {
+            throw new Error(`Invalid ${field}: expected finite number`);
+        }
+        return num;
+    }
+    async invoke(action, payload) {
+        try {
+            const bridge = this.ensureAutomationBridge();
+            const response = await bridge.sendAutomationRequest(action, payload, { timeoutMs: 40000 });
+            if (response.success === false) {
+                return {
+                    success: false,
+                    error: typeof response.error === 'string' && response.error.length > 0 ? response.error : 'ENVIRONMENT_CONTROL_FAILED',
+                    message: typeof response.message === 'string' ? response.message : undefined,
+                    details: typeof response.result === 'object' && response.result ? response.result : undefined
+                };
+            }
+            const resultPayload = typeof response.result === 'object' && response.result ? response.result : undefined;
+            return {
+                success: true,
+                message: typeof response.message === 'string' ? response.message : 'Environment control action succeeded',
+                details: resultPayload
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                error: message || 'ENVIRONMENT_CONTROL_FAILED'
+            };
+        }
+    }
+    async setTimeOfDay(hour) {
+        const normalizedHour = this.normalizeNumber(hour, 'hour', this.getDefaultTimeOfDay());
+        const clampedHour = Math.min(Math.max(normalizedHour, 0), 24);
+        return this.invoke('set_time_of_day', { hour: clampedHour });
+    }
+    async setSunIntensity(intensity) {
+        const normalized = this.normalizeNumber(intensity, 'intensity', this.getDefaultSunIntensity());
+        const finalValue = Math.max(normalized, 0);
+        return this.invoke('set_sun_intensity', { intensity: finalValue });
+    }
+    async setSkylightIntensity(intensity) {
+        const normalized = this.normalizeNumber(intensity, 'intensity', this.getDefaultSkylightIntensity());
+        const finalValue = Math.max(normalized, 0);
+        return this.invoke('set_skylight_intensity', { intensity: finalValue });
+    }
+    async exportSnapshot(params) {
+        try {
+            const rawPath = typeof params?.path === 'string' && params.path.trim().length > 0
+                ? params.path.trim()
+                : './tests/reports/env_snapshot.json';
+            const rawFilename = typeof params?.filename === 'string' && params.filename.trim().length > 0
+                ? params.filename.trim()
+                : undefined;
+            let targetPath;
+            if (rawFilename) {
+                const dir = rawPath;
+                targetPath = path.isAbsolute(dir)
+                    ? path.join(dir, rawFilename)
+                    : path.join(process.cwd(), dir, rawFilename);
+            }
+            else {
+                const hasExt = /\.[a-z0-9]+$/i.test(rawPath);
+                if (hasExt) {
+                    targetPath = path.isAbsolute(rawPath)
+                        ? rawPath
+                        : path.join(process.cwd(), rawPath);
+                }
+                else {
+                    const dir = rawPath;
+                    const filename = 'env_snapshot.json';
+                    targetPath = path.isAbsolute(dir)
+                        ? path.join(dir, filename)
+                        : path.join(process.cwd(), dir, filename);
+                }
+            }
+            await fs.mkdir(path.dirname(targetPath), { recursive: true });
+            const snapshot = {
+                generatedAt: new Date().toISOString(),
+                timeOfDay: this.getDefaultTimeOfDay(),
+                sunIntensity: this.getDefaultSunIntensity(),
+                skylightIntensity: this.getDefaultSkylightIntensity()
+            };
+            await fs.writeFile(targetPath, JSON.stringify(snapshot, null, 2), 'utf8');
+            return {
+                success: true,
+                message: `Environment snapshot exported to ${targetPath}`,
+                details: { path: targetPath }
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                error: `Failed to export environment snapshot: ${message}`
+            };
+        }
+    }
+    async importSnapshot(params) {
+        const rawPath = typeof params?.path === 'string' && params.path.trim().length > 0
+            ? params.path.trim()
+            : './tests/reports/env_snapshot.json';
+        const rawFilename = typeof params?.filename === 'string' && params.filename.trim().length > 0
+            ? params.filename.trim()
+            : undefined;
+        let targetPath;
+        if (rawFilename) {
+            const dir = rawPath;
+            targetPath = path.isAbsolute(dir)
+                ? path.join(dir, rawFilename)
+                : path.join(process.cwd(), dir, rawFilename);
+        }
+        else {
+            const hasExt = /\.[a-z0-9]+$/i.test(rawPath);
+            if (hasExt) {
+                targetPath = path.isAbsolute(rawPath)
+                    ? rawPath
+                    : path.join(process.cwd(), rawPath);
+            }
+            else {
+                const dir = rawPath;
+                const filename = 'env_snapshot.json';
+                targetPath = path.isAbsolute(dir)
+                    ? path.join(dir, filename)
+                    : path.join(process.cwd(), dir, filename);
+            }
+        }
+        try {
+            let parsed = undefined;
+            try {
+                const contents = await fs.readFile(targetPath, 'utf8');
+                try {
+                    parsed = JSON.parse(contents);
+                }
+                catch {
+                    parsed = undefined;
+                }
+            }
+            catch (err) {
+                if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) {
+                    return {
+                        success: true,
+                        message: `Environment snapshot file not found at ${targetPath}; import treated as no-op`
+                    };
+                }
+                throw err;
+            }
+            return {
+                success: true,
+                message: `Environment snapshot import handled from ${targetPath}`,
+                details: parsed && typeof parsed === 'object' ? parsed : undefined
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                error: `Failed to import environment snapshot: ${message}`
+            };
+        }
+    }
+    async cleanup(params) {
+        try {
+            const rawNames = Array.isArray(params?.names) ? params.names : [];
+            if (typeof params?.name === 'string' && params.name.trim().length > 0) {
+                rawNames.push(params.name);
+            }
+            const cleaned = rawNames
+                .filter((name) => typeof name === 'string')
+                .map((name) => name.trim())
+                .filter((name) => name.length > 0);
+            if (cleaned.length === 0) {
+                return {
+                    success: true,
+                    message: 'No environment actor names provided for cleanup; no-op'
+                };
+            }
+            const bridge = this.ensureAutomationBridge();
+            const resp = await bridge.sendAutomationRequest('build_environment', {
+                action: 'delete',
+                names: cleaned
+            }, { timeoutMs: 40000 });
+            if (!resp || resp.success === false) {
+                const result = resp && typeof resp.result === 'object' ? resp.result : undefined;
+                return {
+                    success: false,
+                    error: typeof resp?.error === 'string' && resp.error.length > 0
+                        ? resp.error
+                        : (typeof resp?.message === 'string' && resp.message.length > 0
+                            ? resp.message
+                            : 'Failed to delete environment actors'),
+                    message: typeof resp?.message === 'string' ? resp.message : undefined,
+                    details: result
+                };
+            }
+            const result = resp && typeof resp.result === 'object' ? resp.result : undefined;
+            return {
+                success: true,
+                message: typeof resp.message === 'string' && resp.message.length > 0
+                    ? resp.message
+                    : `Environment actors deleted: ${cleaned.join(', ')}`,
+                details: result ?? { names: cleaned }
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                success: false,
+                error: `Failed to cleanup environment actors: ${message}`
+            };
+        }
+    }
+}
+//# sourceMappingURL=environment.js.map

package/dist/tools/foliage.d.ts

@@ -1,7 +1,11 @@
 import { UnrealBridge } from '../unreal-bridge.js';
-export declare class FoliageTools {
+import { AutomationBridge } from '../automation/index.js';
+import { IFoliageTools, StandardActionResponse } from '../types/tool-interfaces.js';
+export declare class FoliageTools implements IFoliageTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     addFoliageType(params: {
         name: string;
         meshPath: string;
@@ -12,71 +16,21 @@ export declare class FoliageTools {
         alignToNormal?: boolean;
         randomYaw?: boolean;
         groundSlope?: number;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        note?: undefined;
-        created?: undefined;
-        exists?: undefined;
-        method?: undefined;
-        assetPath?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        note: string | undefined;
-        created?: undefined;
-        exists?: undefined;
-        method?: undefined;
-        assetPath?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        created: boolean;
-        exists: boolean;
-        method: string;
-        assetPath: string | undefined;
-        usedMesh: string | undefined;
-        note: string | undefined;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
     paintFoliage(params: {
         foliageType: string;
         position: [number, number, number];
         brushSize?: number;
         paintDensity?: number;
         eraseMode?: boolean;
-    }): Promise<{
-        success: boolean;
-        error: string;
-        note?: undefined;
-        added?: undefined;
-        actor?: undefined;
-        component?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        error: string;
-        note: string | undefined;
-        added?: undefined;
-        actor?: undefined;
-        component?: undefined;
-        usedMesh?: undefined;
-        message?: undefined;
-    } | {
-        success: boolean;
-        added: number;
-        actor: string | undefined;
-        component: string | undefined;
-        usedMesh: string | undefined;
-        note: string | undefined;
-        message: string;
-        error?: undefined;
-    }>;
+    }): Promise<StandardActionResponse>;
+    getFoliageInstances(params: {
+        foliageType?: string;
+    }): Promise<StandardActionResponse>;
+    removeFoliage(params: {
+        foliageType?: string;
+        removeAll?: boolean;
+    }): Promise<StandardActionResponse>;
     createInstancedMesh(params: {
         name: string;
         meshPath: string;
@@ -87,38 +41,62 @@ export declare class FoliageTools {
         }>;
         enableCulling?: boolean;
         cullDistance?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     setFoliageLOD(params: {
         foliageType: string;
         lodDistances?: number[];
         screenSize?: number[];
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
+    addFoliage(params: {
+        foliageType: string;
+        locations: Array<{
+            x: number;
+            y: number;
+            z: number;
+        }>;
+    }): Promise<StandardActionResponse>;
     createProceduralFoliage(params: {
-        volumeName: string;
-        position: [number, number, number];
-        size: [number, number, number];
-        foliageTypes: string[];
+        name: string;
+        bounds?: {
+            location: {
+                x: number;
+                y: number;
+                z: number;
+            };
+            size: {
+                x: number;
+                y: number;
+                z: number;
+            };
+        };
+        foliageTypes?: Array<{
+            meshPath: string;
+            density: number;
+            minScale?: number;
+            maxScale?: number;
+            alignToNormal?: boolean;
+            randomYaw?: boolean;
+        }>;
+        volumeName?: string;
+        position?: [number, number, number];
+        size?: [number, number, number];
         seed?: number;
         tileSize?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
+    addFoliageInstances(params: {
+        foliageType: string;
+        transforms: Array<{
+            location: [number, number, number];
+            rotation?: [number, number, number];
+            scale?: [number, number, number];
+        }>;
+    }): Promise<StandardActionResponse>;
     setFoliageCollision(params: {
         foliageType: string;
         collisionEnabled?: boolean;
         collisionProfile?: string;
         generateOverlapEvents?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     createGrassSystem(params: {
         name: string;
         grassTypes: Array<{
@@ -129,46 +107,34 @@ export declare class FoliageTools {
         }>;
         windStrength?: number;
         windSpeed?: number;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     removeFoliageInstances(params: {
         foliageType: string;
         position: [number, number, number];
         radius: number;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     selectFoliageInstances(params: {
         foliageType: string;
         position?: [number, number, number];
         radius?: number;
         selectAll?: boolean;
-    }): Promise<any>;
+    }): Promise<StandardActionResponse>;
     updateFoliageInstances(params: {
         foliageType: string;
         updateTransforms?: boolean;
         updateMesh?: boolean;
         newMeshPath?: string;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     createFoliageSpawner(params: {
         name: string;
         spawnArea: 'Landscape' | 'StaticMesh' | 'BSP' | 'Foliage' | 'All';
         excludeAreas?: Array<[number, number, number, number]>;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
     optimizeFoliage(params: {
         mergeInstances?: boolean;
         generateClusters?: boolean;
         clusterSize?: number;
         reduceDrawCalls?: boolean;
-    }): Promise<{
-        success: boolean;
-        message: string;
-    }>;
+    }): Promise<StandardActionResponse>;
 }
 //# sourceMappingURL=foliage.d.ts.map