unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/utils/normalize.test.ts

@@ -1,162 +0,0 @@
-/**
- * Unit tests for normalize utility functions
- */
-import { describe, it, expect } from 'vitest';
-import {
-    toVec3Object,
-    toRotObject,
-    toVec3Tuple,
-    toRotTuple,
-    toFiniteNumber,
-    normalizePartialVector,
-    normalizeTransformInput
-} from './normalize.js';
-
-describe('toVec3Object', () => {
-    it('converts object input to Vector3', () => {
-        const result = toVec3Object({ x: 1, y: 2, z: 3 });
-        expect(result).toEqual({ x: 1, y: 2, z: 3 });
-    });
-
-    it('converts array input to Vector3', () => {
-        const result = toVec3Object([1, 2, 3]);
-        expect(result).toEqual({ x: 1, y: 2, z: 3 });
-    });
-
-    it('returns null for invalid input', () => {
-        expect(toVec3Object('invalid')).toBeNull();
-        expect(toVec3Object(null)).toBeNull();
-        expect(toVec3Object(undefined)).toBeNull();
-    });
-
-    it('returns null for incomplete object', () => {
-        expect(toVec3Object({ x: 1, y: 2 })).toBeNull();
-    });
-
-    it('handles zero values', () => {
-        const result = toVec3Object({ x: 0, y: 0, z: 0 });
-        expect(result).toEqual({ x: 0, y: 0, z: 0 });
-    });
-});
-
-describe('toRotObject', () => {
-    it('converts object input to Rotator', () => {
-        const result = toRotObject({ pitch: 10, yaw: 20, roll: 30 });
-        expect(result).toEqual({ pitch: 10, yaw: 20, roll: 30 });
-    });
-
-    it('converts array input to Rotator', () => {
-        const result = toRotObject([10, 20, 30]);
-        expect(result).toEqual({ pitch: 10, yaw: 20, roll: 30 });
-    });
-
-    it('returns null for invalid input', () => {
-        expect(toRotObject('invalid')).toBeNull();
-        expect(toRotObject(null)).toBeNull();
-    });
-});
-
-describe('toVec3Tuple', () => {
-    it('converts object to tuple', () => {
-        const result = toVec3Tuple({ x: 1, y: 2, z: 3 });
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    it('passes through valid array', () => {
-        const result = toVec3Tuple([1, 2, 3]);
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    it('returns null for invalid input', () => {
-        expect(toVec3Tuple([1, 2])).toBeNull();
-        expect(toVec3Tuple(null)).toBeNull();
-    });
-});
-
-describe('toRotTuple', () => {
-    it('converts object to tuple', () => {
-        const result = toRotTuple({ pitch: 10, yaw: 20, roll: 30 });
-        expect(result).toEqual([10, 20, 30]);
-    });
-
-    it('passes through valid array', () => {
-        const result = toRotTuple([10, 20, 30]);
-        expect(result).toEqual([10, 20, 30]);
-    });
-});
-
-describe('toFiniteNumber', () => {
-    it('accepts valid numbers', () => {
-        expect(toFiniteNumber(42)).toBe(42);
-        expect(toFiniteNumber(0)).toBe(0);
-        expect(toFiniteNumber(-5)).toBe(-5);
-        expect(toFiniteNumber(3.14)).toBe(3.14);
-    });
-
-    it('parses string numbers', () => {
-        expect(toFiniteNumber('42')).toBe(42);
-        expect(toFiniteNumber('3.14')).toBe(3.14);
-    });
-
-    it('returns undefined for invalid input', () => {
-        expect(toFiniteNumber('not a number')).toBeUndefined();
-        expect(toFiniteNumber(NaN)).toBeUndefined();
-        expect(toFiniteNumber(Infinity)).toBeUndefined();
-        expect(toFiniteNumber(null)).toBeUndefined();
-        expect(toFiniteNumber(undefined)).toBeUndefined();
-    });
-});
-
-describe('normalizePartialVector', () => {
-    it('normalizes complete vectors', () => {
-        const result = normalizePartialVector({ x: 1, y: 2, z: 3 });
-        expect(result).toEqual({ x: 1, y: 2, z: 3 });
-    });
-
-    it('handles partial vectors', () => {
-        const result = normalizePartialVector({ x: 1 });
-        expect(result).toBeDefined();
-        expect(result?.x).toBe(1);
-    });
-
-    it('uses alternate keys for reading input', () => {
-        const result = normalizePartialVector(
-            { pitch: 10, yaw: 20, roll: 30 },
-            ['pitch', 'yaw', 'roll']
-        );
-        // alternateKeys are used to READ from input, but output is still x/y/z
-        expect(result).toEqual({ x: 10, y: 20, z: 30 });
-    });
-
-    it('returns undefined for invalid input', () => {
-        expect(normalizePartialVector(null)).toBeUndefined();
-        expect(normalizePartialVector('string')).toBeUndefined();
-    });
-});
-
-describe('normalizeTransformInput', () => {
-    it('normalizes complete transform', () => {
-        const result = normalizeTransformInput({
-            location: { x: 0, y: 0, z: 100 },
-            rotation: { pitch: 0, yaw: 90, roll: 0 },
-            scale: { x: 1, y: 1, z: 1 }
-        });
-        expect(result).toBeDefined();
-        expect(result?.location).toBeDefined();
-        expect(result?.rotation).toBeDefined();
-        expect(result?.scale).toBeDefined();
-    });
-
-    it('handles partial transforms', () => {
-        const result = normalizeTransformInput({
-            location: { x: 100, y: 200, z: 300 }
-        });
-        expect(result).toBeDefined();
-        expect(result?.location).toBeDefined();
-    });
-
-    it('returns undefined for invalid input', () => {
-        expect(normalizeTransformInput(null)).toBeUndefined();
-        expect(normalizeTransformInput('invalid')).toBeUndefined();
-    });
-});

package/src/utils/normalize.ts

@@ -1,146 +0,0 @@
-export interface Vec3Obj { x: number; y: number; z: number; }
-export interface Rot3Obj { pitch: number; yaw: number; roll: number; }
-
-export type Vec3Tuple = [number, number, number];
-export type Rot3Tuple = [number, number, number];
-
-/** Input that may represent a 3D vector */
-type VectorInput = Vec3Obj | Vec3Tuple | Record<string, unknown> | unknown[];
-
-/** Input that may represent a 3D rotation */
-type RotationInput = Rot3Obj | Rot3Tuple | Record<string, unknown> | unknown[];
-
-/**
- * Convert various input formats to a Vec3 object
- * @param input - Array, object with x/y/z or X/Y/Z properties
- */
-export function toVec3Object(input: VectorInput | unknown): Vec3Obj | null {
-  try {
-    if (Array.isArray(input) && input.length === 3) {
-      const [x, y, z] = input;
-      if ([x, y, z].every(v => typeof v === 'number' && isFinite(v))) {
-        return { x: x as number, y: y as number, z: z as number };
-      }
-    }
-    if (input && typeof input === 'object' && !Array.isArray(input)) {
-      const obj = input as Record<string, unknown>;
-      const x = Number(obj.x ?? obj.X);
-      const y = Number(obj.y ?? obj.Y);
-      const z = Number(obj.z ?? obj.Z);
-      if ([x, y, z].every(v => typeof v === 'number' && !isNaN(v) && isFinite(v))) {
-        return { x, y, z };
-      }
-    }
-  } catch { }
-  return null;
-}
-
-/**
- * Convert various input formats to a Rotation object
- * @param input - Array, object with pitch/yaw/roll or Pitch/Yaw/Roll properties
- */
-export function toRotObject(input: RotationInput | unknown): Rot3Obj | null {
-  try {
-    if (Array.isArray(input) && input.length === 3) {
-      const [pitch, yaw, roll] = input;
-      if ([pitch, yaw, roll].every(v => typeof v === 'number' && isFinite(v))) {
-        return { pitch: pitch as number, yaw: yaw as number, roll: roll as number };
-      }
-    }
-    if (input && typeof input === 'object' && !Array.isArray(input)) {
-      const obj = input as Record<string, unknown>;
-      const pitch = Number(obj.pitch ?? obj.Pitch);
-      const yaw = Number(obj.yaw ?? obj.Yaw);
-      const roll = Number(obj.roll ?? obj.Roll);
-      if ([pitch, yaw, roll].every(v => typeof v === 'number' && !isNaN(v) && isFinite(v))) {
-        return { pitch, yaw, roll };
-      }
-    }
-  } catch { }
-  return null;
-}
-
-/**
- * Convert vector input to a tuple format [x, y, z]
- */
-export function toVec3Tuple(input: VectorInput | unknown): Vec3Tuple | null {
-  const vec = toVec3Object(input);
-  if (!vec) {
-    return null;
-  }
-  const { x, y, z } = vec;
-  return [x, y, z];
-}
-
-/**
- * Convert rotation input to a tuple format [pitch, yaw, roll]
- */
-export function toRotTuple(input: RotationInput | unknown): Rot3Tuple | null {
-  const rot = toRotObject(input);
-  if (!rot) {
-    return null;
-  }
-  const { pitch, yaw, roll } = rot;
-  return [pitch, yaw, roll];
-}
-
-/**
- * Parse a raw value into a finite number when possible.
- * Accepts strings like "1.0" and returns number or undefined when invalid.
- */
-export function toFiniteNumber(raw: unknown): number | undefined {
-  if (typeof raw === 'number' && Number.isFinite(raw)) return raw;
-  if (typeof raw === 'string') {
-    const trimmed = raw.trim();
-    if (trimmed.length === 0) return undefined;
-    const parsed = Number(trimmed);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return undefined;
-}
-
-/**
- * Normalize a partial vector input. Unlike toVec3Object, this accepts
- * partial specifications and returns an object containing only present
- * components (x/y/z) when any are provided; otherwise returns undefined.
- */
-export function normalizePartialVector(value: any, alternateKeys: string[] = ['x', 'y', 'z']): Record<string, number> | undefined {
-  if (value === undefined || value === null) return undefined;
-  const result: Record<string, number> = {};
-  const assignIfPresent = (component: 'x' | 'y' | 'z', raw: unknown) => {
-    const num = toFiniteNumber(raw);
-    if (num !== undefined) result[component] = num;
-  };
-
-  if (Array.isArray(value)) {
-    if (value.length > 0) assignIfPresent('x', value[0]);
-    if (value.length > 1) assignIfPresent('y', value[1]);
-    if (value.length > 2) assignIfPresent('z', value[2]);
-  } else if (typeof value === 'object') {
-    const obj = value as Record<string, unknown>;
-    assignIfPresent('x', obj.x ?? obj[alternateKeys[0]]);
-    assignIfPresent('y', obj.y ?? obj[alternateKeys[1]]);
-    assignIfPresent('z', obj.z ?? obj[alternateKeys[2]]);
-  } else {
-    assignIfPresent('x', value);
-  }
-
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-
-/**
- * Normalize a transform-like input into a minimal object containing
- * location/rotation/scale partial descriptors when present.
- */
-export function normalizeTransformInput(transform: any): Record<string, unknown> | undefined {
-  if (!transform || typeof transform !== 'object') return undefined;
-  const result: Record<string, unknown> = {};
-  const location = normalizePartialVector(transform.location);
-  if (location) result.location = location;
-  const rotation = normalizePartialVector(transform.rotation, ['pitch', 'yaw', 'roll']);
-  if (rotation) result.rotation = rotation;
-  const scale = normalizePartialVector(transform.scale);
-  if (scale) result.scale = scale;
-  return Object.keys(result).length > 0 ? result : undefined;
-}
-

package/src/utils/path-security.ts

@@ -1,43 +0,0 @@
-export function sanitizePath(path: string, allowedRoots: string[] = ['/Game', '/Engine']): string {
-    if (!path || typeof path !== 'string') {
-        throw new Error('Invalid path: must be a non-empty string');
-    }
-
-    const trimmed = path.trim();
-    if (trimmed.length === 0) {
-        throw new Error('Invalid path: cannot be empty');
-    }
-
-    // Normalize separators
-    const normalized = trimmed.replace(/\\/g, '/');
-
-    // Prevent directory traversal
-    if (normalized.includes('..')) {
-        throw new Error('Invalid path: directory traversal (..) is not allowed');
-    }
-
-    // Ensure path starts with a valid root
-    // We check case-insensitive for the root prefix to be user-friendly, 
-    // but Unreal paths are typically case-insensitive anyway.
-    const isAllowed = allowedRoots.some(root =>
-        normalized.toLowerCase() === root.toLowerCase() ||
-        normalized.toLowerCase().startsWith(`${root.toLowerCase()}/`)
-    );
-
-    if (!isAllowed) {
-        throw new Error(`Invalid path: must start with one of [${allowedRoots.join(', ')}]`);
-    }
-
-    // Basic character validation (Unreal strictness)
-    // Blocks: < > : " | ? * (Windows reserved) and control characters
-    // allowing spaces, dots, underscores, dashes, slashes
-    // Note: Unreal allows spaces in some contexts but it's often safer to restrict them if strict mode is desired.
-    // For now, we block the definitely invalid ones.
-    // eslint-disable-next-line no-control-regex
-    const invalidChars = /[<>:"|?*\x00-\x1f]/;
-    if (invalidChars.test(normalized)) {
-        throw new Error('Invalid path: contains illegal characters');
-    }
-
-    return normalized;
-}

package/src/utils/response-factory.ts

@@ -1,44 +0,0 @@
-import { StandardActionResponse } from '../types/tool-interfaces.js';
-import { cleanObject } from './safe-json.js';
-
-export class ResponseFactory {
-    /**
-     * Create a standard success response
-     */
-    static success(data: any, message: string = 'Operation successful'): StandardActionResponse {
-        return {
-            success: true,
-            message,
-            data: cleanObject(data)
-        };
-    }
-
-    /**
-     * Create a standard error response
-     * @param error The error object or message
-     * @param defaultMessage Fallback message if error is not an Error object
-     */
-    static error(error: any, defaultMessage: string = 'Operation failed'): StandardActionResponse {
-        const errorMessage = error instanceof Error ? error.message : String(error || defaultMessage);
-
-        // Log the full error for debugging (internal logs) but return a clean message to the client
-        console.error('[ResponseFactory] Error:', error);
-
-        return {
-            success: false,
-            message: errorMessage,
-            data: null
-        };
-    }
-
-    /**
-     * Create a validation error response
-     */
-    static validationError(message: string): StandardActionResponse {
-        return {
-            success: false,
-            message: `Validation Error: ${message}`,
-            data: null
-        };
-    }
-}