unreal-engine-mcp-server 0.5.0 → 0.5.1

package/src/utils/response-factory.ts

@@ -1,39 +1,44 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { StandardActionResponse } from '../types/tool-interfaces.js';
+import { cleanObject } from './safe-json.js';
 
 export class ResponseFactory {
-    static success(message: string, data?: unknown): CallToolResult {
-        const content: any[] = [{ type: 'text', text: message }];
-
-        if (data) {
-            content.push({
-                type: 'text',
-                text: JSON.stringify(data, null, 2)
-            });
-        }
-
+    /**
+     * Create a standard success response
+     */
+    static success(data: any, message: string = 'Operation successful'): StandardActionResponse {
         return {
-            content,
-            isError: false
+            success: true,
+            message,
+            data: cleanObject(data)
         };
     }
 
-    static error(message: string, error?: unknown): CallToolResult {
-        const errorText = error instanceof Error ? error.message : String(error);
-        const fullMessage = error ? `${message}: ${errorText}` : message;
+    /**
+     * 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 {
-            content: [{ type: 'text', text: fullMessage }],
-            isError: true
+            success: false,
+            message: errorMessage,
+            data: null
         };
     }
 
-    static json(data: unknown): CallToolResult {
+    /**
+     * Create a validation error response
+     */
+    static validationError(message: string): StandardActionResponse {
         return {
-            content: [{
-                type: 'text',
-                text: JSON.stringify(data, null, 2)
-            }],
-            isError: false
+            success: false,
+            message: `Validation Error: ${message}`,
+            data: null
         };
     }
 }

package/src/utils/safe-json.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Unit tests for safe-json utility
+ */
+import { describe, it, expect } from 'vitest';
+import { cleanObject } from './safe-json.js';
+
+describe('cleanObject', () => {
+    it('removes undefined values', () => {
+        const input = { a: 1, b: undefined, c: 3 };
+        const result = cleanObject(input);
+        expect(result).toEqual({ a: 1, c: 3 });
+        expect('b' in result).toBe(false);
+    });
+
+    it('preserves null values (only removes undefined)', () => {
+        const input = { a: 1, b: null, c: 3 };
+        const result = cleanObject(input);
+        // cleanObject preserves null, only removes undefined
+        expect(result).toEqual({ a: 1, b: null, c: 3 });
+    });
+
+    it('handles nested objects', () => {
+        const input = { a: 1, nested: { b: 2, c: undefined } };
+        const result = cleanObject(input);
+        expect(result.nested).toEqual({ b: 2 });
+    });
+
+    it('handles arrays with undefined (preserves null)', () => {
+        const input = { arr: [1, undefined, 3, null] };
+        const result = cleanObject(input);
+        // Arrays preserve their structure, undefined becomes undefined in array
+        expect(result.arr).toEqual([1, undefined, 3, null]);
+    });
+
+    it('preserves falsy values that are not null/undefined', () => {
+        const input = { a: 0, b: '', c: false };
+        const result = cleanObject(input);
+        expect(result).toEqual({ a: 0, b: '', c: false });
+    });
+
+    it('handles empty objects', () => {
+        expect(cleanObject({})).toEqual({});
+    });
+
+    it('handles primitive inputs', () => {
+        expect(cleanObject('string')).toBe('string');
+        expect(cleanObject(42)).toBe(42);
+        expect(cleanObject(true)).toBe(true);
+    });
+
+    it('respects max depth limit', () => {
+        // Create deeply nested object
+        let deep: any = { value: 'deep' };
+        for (let i = 0; i < 15; i++) {
+            deep = { nested: deep };
+        }
+
+        // Should not throw when hitting depth limit
+        expect(() => cleanObject(deep, 10)).not.toThrow();
+    });
+
+    it('handles circular reference prevention at max depth', () => {
+        const obj: any = { a: 1 };
+        obj.self = obj; // circular reference
+
+        // Should not throw - depth limiting should prevent infinite recursion
+        expect(() => cleanObject(obj, 5)).not.toThrow();
+    });
+
+    it('handles Date objects (converts to empty object)', () => {
+        const date = new Date('2024-01-01');
+        const input = { created: date };
+        const result = cleanObject(input);
+        // Date objects are processed as objects using Object.keys, which returns []
+        expect(result.created).toEqual({});
+    });
+
+    it('handles empty arrays', () => {
+        const input = { arr: [] };
+        const result = cleanObject(input);
+        expect(result.arr).toEqual([]);
+    });
+
+    it('handles NaN values', () => {
+        const input = { a: 1, b: NaN };
+        const result = cleanObject(input);
+        // NaN handling depends on implementation
+        expect(result.a).toBe(1);
+    });
+});

package/src/utils/validation.test.ts

@@ -0,0 +1,184 @@
+/**
+ * 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', () => {
+        const result = sanitizePath('/Game/../MyAsset');
+        // Each segment is sanitized, .. becomes a segment that gets sanitized
+        expect(result).toContain('/');
+    });
+});
+
+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();
+    });
+});