unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/utils/safe-json.ts

@@ -1,70 +0,0 @@
-import { Logger } from './logger.js';
-
-// Module-level logger to avoid creating new instances on every call
-const log = new Logger('safe-json');
-
-/**
- * Remove circular references and non-serializable properties from an object.
- * @param obj - The object to clean
- * @param maxDepth - Maximum recursion depth (default: 10)
- * @returns Cleaned object safe for JSON serialization
- */
-export function cleanObject<T = unknown>(obj: T, maxDepth: number = 10): T {
-  const seen = new WeakSet<object>();
-
-  function clean(value: unknown, depth: number, path: string = 'root'): unknown {
-    // Prevent infinite recursion
-    if (depth > maxDepth) {
-      return '[Max depth reached]';
-    }
-
-    // Handle primitives
-    if (value === null || value === undefined) {
-      return value;
-    }
-
-    if (typeof value !== 'object') {
-      if (typeof value === 'function' || typeof value === 'symbol') {
-        return undefined;
-      }
-      if (typeof value === 'bigint') {
-        return value.toString();
-      }
-      return value;
-    }
-
-    // Check for circular reference - keep in set permanently for this call
-    // This prevents the same object from appearing in multiple branches
-    if (seen.has(value)) {
-      return '[Circular Reference]';
-    }
-
-    seen.add(value);
-
-    // Handle arrays
-    if (Array.isArray(value)) {
-      return value.map((item, index) => clean(item, depth + 1, `${path}[${index}]`));
-    }
-
-    // Handle objects
-    const cleaned: Record<string, unknown> = {};
-
-    // Use Object.keys to avoid prototype properties
-    const keys = Object.keys(value as object);
-    for (const key of keys) {
-      try {
-        const cleanedValue = clean((value as Record<string, unknown>)[key], depth + 1, `${path}.${key}`);
-        if (cleanedValue !== undefined) {
-          cleaned[key] = cleanedValue;
-        }
-      } catch (e) {
-        // Skip properties that throw errors when accessed
-        log.error(`Error cleaning property ${path}.${key}`, e);
-      }
-    }
-
-    return cleaned;
-  }
-
-  return clean(obj, 0) as T;
-}

package/src/utils/unreal-command-queue.ts

@@ -1,166 +0,0 @@
-import { Logger } from './logger.js';
-
-export interface CommandQueueItem<T = any> {
-  command: () => Promise<T>;
-  resolve: (value: T) => void;
-  reject: (reason?: any) => void;
-  priority: number;
-  retryCount?: number;
-}
-
-export class UnrealCommandQueue {
-  private log = new Logger('UnrealCommandQueue');
-  private queue: CommandQueueItem[] = [];
-  private isProcessing = false;
-  private lastCommandTime = 0;
-  private lastStatCommandTime = 0;
-  private processorInterval?: ReturnType<typeof setInterval>;
-
-  // Config
-  private readonly MIN_COMMAND_DELAY = 100;
-  private readonly MAX_COMMAND_DELAY = 500;
-  private readonly STAT_COMMAND_DELAY = 300;
-
-  constructor() {
-    this.startProcessor();
-  }
-
-  /**
-   * Execute a command with priority-based throttling
-   */
-  async execute<T>(command: () => Promise<T>, priority: number = 5): Promise<T> {
-    return new Promise((resolve, reject) => {
-      this.queue.push({
-        command,
-        resolve,
-        reject,
-        priority
-      });
-
-      // Sort by priority (lower number = higher priority)
-      this.queue.sort((a, b) => a.priority - b.priority);
-
-      // Process queue if not already processing
-      if (!this.isProcessing) {
-        this.processQueue();
-      }
-    });
-  }
-
-  private async processQueue(): Promise<void> {
-    if (this.isProcessing || this.queue.length === 0) {
-      return;
-    }
-
-    this.isProcessing = true;
-
-    while (this.queue.length > 0) {
-      const item = this.queue.shift();
-      if (!item) continue;
-
-      // Calculate delay based on time since last command
-      const timeSinceLastCommand = Date.now() - this.lastCommandTime;
-      const requiredDelay = this.calculateDelay(item.priority);
-
-      if (timeSinceLastCommand < requiredDelay) {
-        await this.delay(requiredDelay - timeSinceLastCommand);
-      }
-
-      try {
-        const result = await item.command();
-        item.resolve(result);
-      } catch (error: any) {
-        // Enhanced retry policy
-        const msgRaw = error?.message ?? String(error);
-        const msg = String(msgRaw).toLowerCase();
-        if (item.retryCount === undefined) item.retryCount = 0;
-
-        const isTransient = (
-          msg.includes('timeout') ||
-          msg.includes('timed out') ||
-          msg.includes('connect') ||
-          msg.includes('econnrefused') ||
-          msg.includes('econnreset') ||
-          msg.includes('broken pipe') ||
-          msg.includes('automation bridge') ||
-          msg.includes('not connected')
-        );
-
-        const isDeterministicFailure = (
-          msg.includes('command not executed') ||
-          msg.includes('exec_failed') ||
-          msg.includes('invalid command') ||
-          msg.includes('invalid argument') ||
-          msg.includes('unknown_plugin_action') ||
-          msg.includes('unknown action')
-        );
-
-        if (isTransient && item.retryCount < 3) {
-          item.retryCount++;
-          this.log.warn(`Command failed (transient), retrying (${item.retryCount}/3)`);
-          this.queue.unshift({
-            command: item.command,
-            resolve: item.resolve,
-            reject: item.reject,
-            priority: Math.max(1, item.priority - 1),
-            retryCount: item.retryCount
-          });
-          await this.delay(500);
-        } else {
-          if (isDeterministicFailure) {
-            this.log.warn(`Command failed (non-retryable): ${msgRaw}`);
-          }
-          item.reject(error);
-        }
-      }
-
-      this.lastCommandTime = Date.now();
-    }
-
-    this.isProcessing = false;
-  }
-
-  private calculateDelay(priority: number): number {
-    if (priority <= 3) {
-      return this.MAX_COMMAND_DELAY;
-    } else if (priority <= 6) {
-      return 200;
-    } else if (priority === 8) {
-      const timeSinceLastStat = Date.now() - this.lastStatCommandTime;
-      if (timeSinceLastStat < this.STAT_COMMAND_DELAY) {
-        return this.STAT_COMMAND_DELAY;
-      }
-      this.lastStatCommandTime = Date.now();
-      return 150;
-    } else {
-      const baseDelay = this.MIN_COMMAND_DELAY;
-      const jitter = Math.random() * 50;
-      return baseDelay + jitter;
-    }
-  }
-
-  private startProcessor(): void {
-    // Fallback processor - primary processing is triggered directly from execute()
-    // Reduced from 1000ms to 250ms for faster recovery if processor stalls
-    this.processorInterval = setInterval(() => {
-      if (!this.isProcessing && this.queue.length > 0) {
-        this.processQueue();
-      }
-    }, 250);
-  }
-
-  /**
-   * Stop the command queue processor and clean up the interval.
-   * Should be called during shutdown to allow clean process exit.
-   */
-  stopProcessor(): void {
-    if (this.processorInterval) {
-      clearInterval(this.processorInterval);
-      this.processorInterval = undefined;
-    }
-  }
-
-  private delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}

package/src/utils/validation.test.ts

@@ -1,184 +0,0 @@
-/**
- * Unit tests for validation utility functions
- */
-import { describe, it, expect } from 'vitest';
-import {
-    sanitizeAssetName,
-    sanitizePath,
-    validatePathLength,
-    validateAssetParams,
-    validateNumber,
-    ensureVector3,
-    ensureRotation
-} from './validation.js';
-
-describe('sanitizeAssetName', () => {
-    it('removes invalid characters', () => {
-        // ! is replaced with _, then trailing _ is stripped
-        expect(sanitizeAssetName('My Asset!')).toBe('My_Asset');
-    });
-
-    it('removes leading/trailing whitespace', () => {
-        expect(sanitizeAssetName('  MyAsset  ')).toBe('MyAsset');
-    });
-
-    it('preserves valid names', () => {
-        expect(sanitizeAssetName('ValidName_123')).toBe('ValidName_123');
-    });
-
-    it('replaces spaces with underscores', () => {
-        expect(sanitizeAssetName('My Cool Asset')).toBe('My_Cool_Asset');
-    });
-
-    it('handles empty strings', () => {
-        const result = sanitizeAssetName('');
-        expect(result.length).toBeGreaterThan(0);
-    });
-
-    it('removes consecutive underscores', () => {
-        const result = sanitizeAssetName('My__Asset');
-        expect(result).not.toContain('__');
-    });
-});
-
-describe('sanitizePath', () => {
-    it('normalizes forward slashes', () => {
-        const result = sanitizePath('/Game/MyAsset');
-        expect(result).toContain('/');
-        expect(result).not.toContain('\\\\');
-    });
-
-    it('removes double slashes', () => {
-        const result = sanitizePath('/Game//MyAsset');
-        expect(result).not.toContain('//');
-    });
-
-    it('handles backslashes', () => {
-        const result = sanitizePath('\\Game\\MyAsset');
-        expect(result).toContain('/');
-    });
-
-    it('sanitizes path segments with dots', () => {
-        expect(() => sanitizePath('/Game/../MyAsset')).toThrow(
-            'Path traversal (..) is not allowed'
-        );
-    });
-});
-
-describe('validatePathLength', () => {
-    it('accepts valid short paths', () => {
-        const result = validatePathLength('/Game/MyAsset');
-        expect(result.valid).toBe(true);
-    });
-
-    it('accepts empty paths (length 0 < 260)', () => {
-        const result = validatePathLength('');
-        // Empty string has length 0, which is < 260, so it's valid
-        expect(result.valid).toBe(true);
-    });
-
-    it('rejects excessively long paths', () => {
-        const longPath = '/Game/' + 'a'.repeat(300);
-        const result = validatePathLength(longPath);
-        expect(result.valid).toBe(false);
-        expect(result.error).toBeDefined();
-    });
-});
-
-describe('validateAssetParams', () => {
-    it('validates correct create params', () => {
-        const result = validateAssetParams({
-            action: 'create',
-            name: 'MyAsset',
-            path: '/Game/Assets'
-        });
-        expect(result.valid).toBe(true);
-    });
-
-    it('handles names that need sanitization', () => {
-        const result = validateAssetParams({
-            name: '',
-            savePath: '/Game'
-        });
-        // Empty name gets sanitized to 'Asset', so this should be valid
-        expect(result.valid).toBe(true);
-    });
-
-    it('validates path params', () => {
-        const result = validateAssetParams({
-            name: 'Target',
-            savePath: '/Game/Source'
-        });
-        expect(result.valid).toBe(true);
-    });
-});
-
-describe('validateNumber', () => {
-    it('accepts valid finite numbers', () => {
-        expect(() => validateNumber(42, 'test')).not.toThrow();
-    });
-
-    it('rejects NaN', () => {
-        expect(() => validateNumber(NaN, 'test')).toThrow('expected a finite number');
-    });
-
-    it('rejects Infinity', () => {
-        expect(() => validateNumber(Infinity, 'test')).toThrow();
-    });
-
-    it('respects minimum constraint', () => {
-        expect(() => validateNumber(5, 'test', { min: 10 })).toThrow('must be >=');
-    });
-
-    it('respects maximum constraint', () => {
-        expect(() => validateNumber(15, 'test', { max: 10 })).toThrow('must be <=');
-    });
-
-    it('allows zero by default', () => {
-        expect(() => validateNumber(0, 'test')).not.toThrow();
-    });
-
-    it('rejects zero when allowZero is false', () => {
-        expect(() => validateNumber(0, 'test', { allowZero: false })).toThrow('zero is not allowed');
-    });
-});
-
-describe('ensureVector3', () => {
-    it('accepts object format with x, y, z', () => {
-        const result = ensureVector3({ x: 1, y: 2, z: 3 }, 'location');
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    it('accepts array format', () => {
-        const result = ensureVector3([1, 2, 3], 'location');
-        expect(result).toEqual([1, 2, 3]);
-    });
-
-    it('throws on invalid object', () => {
-        expect(() => ensureVector3({ x: 1 }, 'location')).toThrow();
-    });
-
-    it('throws on wrong array length', () => {
-        expect(() => ensureVector3([1, 2], 'location')).toThrow();
-    });
-
-    it('throws on non-number values', () => {
-        expect(() => ensureVector3({ x: 'a', y: 2, z: 3 }, 'location')).toThrow();
-    });
-});
-
-describe('ensureRotation', () => {
-    it('accepts object format with pitch, yaw, roll', () => {
-        const result = ensureRotation({ pitch: 0, yaw: 90, roll: 0 }, 'rotation');
-        expect(result).toEqual([0, 90, 0]);
-    });
-
-    it('accepts array format', () => {
-        const result = ensureRotation([0, 90, 0], 'rotation');
-        expect(result).toEqual([0, 90, 0]);
-    });
-
-    it('throws on invalid input', () => {
-        expect(() => ensureRotation('invalid', 'rotation')).toThrow();
-    });
-});