unreal-engine-mcp-server 0.5.0 → 0.5.2

package/dist/types/tool-types.d.ts

@@ -3,6 +3,8 @@ export interface BaseToolResponse {
     message?: string;
     error?: string;
     warning?: string;
+    retriable?: boolean;
+    scope?: string;
 }
 export interface AssetInfo {
     Name: string;

package/dist/unreal-bridge.js

@@ -206,7 +206,7 @@ export class UnrealBridge {
             const success = response.success !== false;
             const rawResult = response.result && typeof response.result === 'object'
                 ? { ...response.result }
-                : response.result;
+                : undefined;
             const value = rawResult?.value ??
                 rawResult?.propertyValue ??
                 (success ? rawResult : undefined);
@@ -295,7 +295,7 @@ export class UnrealBridge {
             const success = response.success !== false;
             const rawResult = response.result && typeof response.result === 'object'
                 ? { ...response.result }
-                : response.result;
+                : undefined;
             if (success) {
                 return {
                     success: true,
@@ -423,7 +423,7 @@ export class UnrealBridge {
             const resp = await bridge.sendAutomationRequest('system_control', { action: 'get_engine_version' }, { timeoutMs: 15000 });
             const raw = resp && typeof resp.result === 'object'
                 ? resp.result
-                : (resp?.result ?? resp ?? {});
+                : resp?.result ?? resp ?? {};
             const version = typeof raw.version === 'string' ? raw.version : 'unknown';
             const major = typeof raw.major === 'number' ? raw.major : 0;
             const minor = typeof raw.minor === 'number' ? raw.minor : 0;
@@ -459,7 +459,7 @@ export class UnrealBridge {
             const resp = await bridge.sendAutomationRequest('system_control', { action: 'get_feature_flags' }, { timeoutMs: 15000 });
             const raw = resp && typeof resp.result === 'object'
                 ? resp.result
-                : (resp?.result ?? resp ?? {});
+                : resp?.result ?? resp ?? {};
             const subs = raw && typeof raw.subsystems === 'object'
                 ? raw.subsystems
                 : {};

package/dist/utils/command-validator.js

@@ -1,18 +1,20 @@
 export class CommandValidator {
     static DANGEROUS_COMMANDS = [
-        'quit', 'exit', 'delete', 'destroy', 'kill', 'crash',
+        'quit', 'exit', 'kill', 'crash',
+        'r.gpucrash', 'r.crash', 'debug crash', 'forcecrash', 'debug break',
+        'assert false', 'check(false)',
         'viewmode visualizebuffer basecolor',
         'viewmode visualizebuffer worldnormal',
-        'r.gpucrash',
-        'buildpaths',
-        'rebuildnavigation'
+        'buildpaths', 'rebuildnavigation',
+        'obj garbage', 'obj list', 'memreport',
+        'delete', 'destroy'
     ];
     static FORBIDDEN_TOKENS = [
         'rm ', 'rm-', 'del ', 'format ', 'shutdown', 'reboot',
         'rmdir', 'mklink', 'copy ', 'move ', 'start "', 'system(',
         'import os', 'import subprocess', 'subprocess.', 'os.system',
         'exec(', 'eval(', '__import__', 'import sys', 'import importlib',
-        'with open', 'open('
+        'with open', 'open(', 'write(', 'read('
     ];
     static INVALID_PATTERNS = [
         /^\d+$/,

package/dist/utils/error-handler.d.ts

@@ -8,8 +8,29 @@ export declare enum ErrorType {
     TIMEOUT = "TIMEOUT",
     UNKNOWN = "UNKNOWN"
 }
+interface ErrorResponseDebug {
+    errorType: ErrorType;
+    originalError: string;
+    stack?: string;
+    context?: Record<string, unknown>;
+    retriable: boolean;
+    scope: string;
+}
+interface ErrorToolResponse extends BaseToolResponse {
+    _debug?: ErrorResponseDebug;
+}
+interface ErrorLike {
+    message?: string;
+    code?: string;
+    type?: string;
+    errorType?: string;
+    stack?: string;
+    response?: {
+        status?: number;
+    };
+}
 export declare class ErrorHandler {
-    static createErrorResponse(error: any, toolName: string, context?: any): BaseToolResponse;
+    static createErrorResponse(error: unknown, toolName: string, context?: Record<string, unknown>): ErrorToolResponse;
     private static categorizeError;
     private static getUserFriendlyMessage;
     private static isRetriable;
@@ -18,7 +39,8 @@ export declare class ErrorHandler {
         initialDelay?: number;
         maxDelay?: number;
         backoffMultiplier?: number;
-        shouldRetry?: (error: any) => boolean;
+        shouldRetry?: (error: ErrorLike | Error | unknown) => boolean;
     }): Promise<T>;
 }
+export {};
 //# sourceMappingURL=error-handler.d.ts.map

package/dist/utils/error-handler.js

@@ -10,43 +10,75 @@ export var ErrorType;
     ErrorType["TIMEOUT"] = "TIMEOUT";
     ErrorType["UNKNOWN"] = "UNKNOWN";
 })(ErrorType || (ErrorType = {}));
+function normalizeErrorToLike(error) {
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack,
+            code: error.code
+        };
+    }
+    if (typeof error === 'object' && error !== null) {
+        const obj = error;
+        return {
+            message: typeof obj.message === 'string' ? obj.message : undefined,
+            code: typeof obj.code === 'string' ? obj.code : undefined,
+            type: typeof obj.type === 'string' ? obj.type : undefined,
+            errorType: typeof obj.errorType === 'string' ? obj.errorType : undefined,
+            stack: typeof obj.stack === 'string' ? obj.stack : undefined,
+            response: typeof obj.response === 'object' && obj.response !== null
+                ? {
+                    status: typeof obj.response.status === 'number'
+                        ? obj.response.status
+                        : undefined
+                }
+                : undefined
+        };
+    }
+    return { message: String(error) };
+}
 export class ErrorHandler {
     static createErrorResponse(error, toolName, context) {
-        const errorType = this.categorizeError(error);
-        const userMessage = this.getUserFriendlyMessage(errorType, error);
-        const retriable = this.isRetriable(error);
+        const errorObj = normalizeErrorToLike(error);
+        const errorType = this.categorizeError(errorObj);
+        const userMessage = this.getUserFriendlyMessage(errorType, errorObj);
+        const retriable = this.isRetriable(errorObj);
         const scope = context?.scope || `tool-call/${toolName}`;
+        const errorMessage = errorObj.message || String(error);
+        const errorStack = errorObj.stack;
         log.error(`Tool ${toolName} failed:`, {
             type: errorType,
-            message: error.message || error,
+            message: errorMessage,
             retriable,
             scope,
             context
         });
-        return {
+        const response = {
             success: false,
             error: userMessage,
             message: `Failed to execute ${toolName}: ${userMessage}`,
-            retriable: retriable,
-            scope: scope,
-            ...(process.env.NODE_ENV === 'development' && {
-                _debug: {
-                    errorType,
-                    originalError: error.message || String(error),
-                    stack: error.stack,
-                    context,
-                    retriable,
-                    scope
-                }
-            })
+            retriable,
+            scope
         };
+        if (process.env.NODE_ENV === 'development') {
+            response._debug = {
+                errorType,
+                originalError: errorMessage,
+                stack: errorStack,
+                context,
+                retriable,
+                scope
+            };
+        }
+        return response;
     }
     static categorizeError(error) {
-        const explicitType = (error?.type || error?.errorType || '').toString().toUpperCase();
+        const errorObj = typeof error === 'object' ? error : null;
+        const explicitType = (errorObj?.type || errorObj?.errorType || '').toString().toUpperCase();
         if (explicitType && Object.values(ErrorType).includes(explicitType)) {
             return explicitType;
         }
-        const errorMessage = error?.message?.toLowerCase() || String(error).toLowerCase();
+        const errorMessage = (errorObj?.message || String(error)).toLowerCase();
         if (errorMessage.includes('econnrefused') ||
             errorMessage.includes('timeout') ||
             errorMessage.includes('connection') ||
@@ -77,7 +109,9 @@ export class ErrorHandler {
         return ErrorType.UNKNOWN;
     }
     static getUserFriendlyMessage(type, error) {
-        const originalMessage = error.message || String(error);
+        const originalMessage = (typeof error === 'object' && error !== null && 'message' in error)
+            ? error.message || String(error)
+            : String(error);
         switch (type) {
             case ErrorType.CONNECTION:
                 return 'Failed to connect to Unreal Engine. Please ensure the Automation Bridge plugin is active and the editor is running.';
@@ -97,9 +131,10 @@ export class ErrorHandler {
     }
     static isRetriable(error) {
         try {
-            const code = (error?.code || '').toString().toUpperCase();
-            const msg = (error?.message || String(error) || '').toLowerCase();
-            const status = Number((error?.response?.status));
+            const errorObj = typeof error === 'object' ? error : null;
+            const code = (errorObj?.code || '').toString().toUpperCase();
+            const msg = (errorObj?.message || String(error) || '').toLowerCase();
+            const status = Number(errorObj?.response?.status);
             if (['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE'].includes(code))
                 return true;
             if (/timeout|timed out|network|connection|closed|unavailable|busy|temporar/.test(msg))

package/dist/utils/normalize.d.ts

@@ -10,11 +10,14 @@ export interface Rot3Obj {
 }
 export type Vec3Tuple = [number, number, number];
 export type Rot3Tuple = [number, number, number];
-export declare function toVec3Object(input: any): Vec3Obj | null;
-export declare function toRotObject(input: any): Rot3Obj | null;
-export declare function toVec3Tuple(input: any): Vec3Tuple | null;
-export declare function toRotTuple(input: any): Rot3Tuple | null;
+type VectorInput = Vec3Obj | Vec3Tuple | Record<string, unknown> | unknown[];
+type RotationInput = Rot3Obj | Rot3Tuple | Record<string, unknown> | unknown[];
+export declare function toVec3Object(input: VectorInput | unknown): Vec3Obj | null;
+export declare function toRotObject(input: RotationInput | unknown): Rot3Obj | null;
+export declare function toVec3Tuple(input: VectorInput | unknown): Vec3Tuple | null;
+export declare function toRotTuple(input: RotationInput | unknown): Rot3Tuple | null;
 export declare function toFiniteNumber(raw: unknown): number | undefined;
 export declare function normalizePartialVector(value: any, alternateKeys?: string[]): Record<string, number> | undefined;
 export declare function normalizeTransformInput(transform: any): Record<string, unknown> | undefined;
+export {};
 //# sourceMappingURL=normalize.d.ts.map

package/dist/utils/normalize.js

@@ -3,13 +3,14 @@ export function toVec3Object(input) {
         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, y, z };
+                return { x: x, y: y, z: z };
             }
         }
-        if (input && typeof input === 'object') {
-            const x = Number(input.x ?? input.X);
-            const y = Number(input.y ?? input.Y);
-            const z = Number(input.z ?? input.Z);
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            const obj = input;
+            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 };
             }
@@ -23,13 +24,14 @@ export function toRotObject(input) {
         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, yaw, roll };
+                return { pitch: pitch, yaw: yaw, roll: roll };
             }
         }
-        if (input && typeof input === 'object') {
-            const pitch = Number(input.pitch ?? input.Pitch);
-            const yaw = Number(input.yaw ?? input.Yaw);
-            const roll = Number(input.roll ?? input.Roll);
+        if (input && typeof input === 'object' && !Array.isArray(input)) {
+            const obj = input;
+            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 };
             }

package/dist/utils/path-security.d.ts

@@ -0,0 +1,2 @@
+export declare function sanitizePath(path: string, allowedRoots?: string[]): string;
+//# sourceMappingURL=path-security.d.ts.map

package/dist/utils/path-security.js

@@ -0,0 +1,24 @@
+export function sanitizePath(path, allowedRoots = ['/Game', '/Engine']) {
+    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');
+    }
+    const normalized = trimmed.replace(/\\/g, '/');
+    if (normalized.includes('..')) {
+        throw new Error('Invalid path: directory traversal (..) is not allowed');
+    }
+    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(', ')}]`);
+    }
+    const invalidChars = /[<>:"|?*\x00-\x1f]/;
+    if (invalidChars.test(normalized)) {
+        throw new Error('Invalid path: contains illegal characters');
+    }
+    return normalized;
+}
+//# sourceMappingURL=path-security.js.map

package/dist/utils/response-factory.d.ts

@@ -1,7 +1,7 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { StandardActionResponse } from '../types/tool-interfaces.js';
 export declare class ResponseFactory {
-    static success(message: string, data?: unknown): CallToolResult;
-    static error(message: string, error?: unknown): CallToolResult;
-    static json(data: unknown): CallToolResult;
+    static success(data: any, message?: string): StandardActionResponse;
+    static error(error: any, defaultMessage?: string): StandardActionResponse;
+    static validationError(message: string): StandardActionResponse;
 }
 //# sourceMappingURL=response-factory.d.ts.map

package/dist/utils/response-factory.js

@@ -1,32 +1,26 @@
+import { cleanObject } from './safe-json.js';
 export class ResponseFactory {
-    static success(message, data) {
-        const content = [{ type: 'text', text: message }];
-        if (data) {
-            content.push({
-                type: 'text',
-                text: JSON.stringify(data, null, 2)
-            });
-        }
+    static success(data, message = 'Operation successful') {
         return {
-            content,
-            isError: false
+            success: true,
+            message,
+            data: cleanObject(data)
         };
     }
-    static error(message, error) {
-        const errorText = error instanceof Error ? error.message : String(error);
-        const fullMessage = error ? `${message}: ${errorText}` : message;
+    static error(error, defaultMessage = 'Operation failed') {
+        const errorMessage = error instanceof Error ? error.message : String(error || defaultMessage);
+        console.error('[ResponseFactory] Error:', error);
         return {
-            content: [{ type: 'text', text: fullMessage }],
-            isError: true
+            success: false,
+            message: errorMessage,
+            data: null
         };
     }
-    static json(data) {
+    static validationError(message) {
         return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify(data, null, 2)
-                }],
-            isError: false
+            success: false,
+            message: `Validation Error: ${message}`,
+            data: null
         };
     }
 }

package/dist/utils/response-validator.js

@@ -21,91 +21,106 @@ function buildSummaryText(toolName, payload) {
         return `${toolName} responded`;
     }
     const effectivePayload = { ...payload };
-    if (isRecord(effectivePayload.data)) {
-        Object.assign(effectivePayload, effectivePayload.data);
-    }
-    if (isRecord(effectivePayload.result)) {
-        Object.assign(effectivePayload, effectivePayload.result);
-    }
-    const parts = [];
-    const listKeys = ['actors', 'levels', 'assets', 'folders', 'blueprints', 'components', 'pawnClasses', 'foliageTypes', 'nodes', 'tracks', 'bindings', 'keys'];
-    for (const key of listKeys) {
-        if (Array.isArray(effectivePayload[key])) {
-            const arr = effectivePayload[key];
-            const names = arr.map(i => isRecord(i) ? (i.name || i.path || i.id || i.assetName || i.objectPath || i.packageName || i.nodeName || '<?>') : String(i));
-            const count = arr.length;
-            const preview = names.slice(0, 100).join(', ');
-            const suffix = count > 100 ? `, ... (+${count - 100} more)` : '';
-            parts.push(`${key}: ${preview}${suffix} (Total: ${count})`);
+    const flattenWrappers = (obj, depth = 0) => {
+        if (depth > 5)
+            return;
+        if (isRecord(obj.data)) {
+            Object.assign(obj, obj.data);
+            delete obj.data;
+            flattenWrappers(obj, depth + 1);
         }
-    }
-    if (typeof effectivePayload.actor === 'string' || isRecord(effectivePayload.actor)) {
-        const a = effectivePayload.actor;
-        const name = isRecord(a) ? (a.name || a.path) : a;
-        const loc = isRecord(effectivePayload.location) ? ` at [${effectivePayload.location.x},${effectivePayload.location.y},${effectivePayload.location.z}]` : '';
-        parts.push(`Actor: ${name}${loc}`);
-    }
-    if (typeof effectivePayload.asset === 'string' || isRecord(effectivePayload.asset)) {
-        const a = effectivePayload.asset;
-        const path = isRecord(a) ? (a.path || a.name) : a;
-        parts.push(`Asset: ${path}`);
-    }
-    if (typeof effectivePayload.blueprint === 'string' || isRecord(effectivePayload.blueprint)) {
-        const bp = effectivePayload.blueprint;
-        const name = isRecord(bp) ? (bp.name || bp.path || effectivePayload.blueprintPath) : bp;
-        parts.push(`Blueprint: ${name}`);
-    }
-    if (typeof effectivePayload.sequence === 'string' || isRecord(effectivePayload.sequence)) {
-        const seq = effectivePayload.sequence;
-        const name = isRecord(seq) ? (seq.name || seq.path) : seq;
-        parts.push(`Sequence: ${name}`);
-    }
-    const usefulKeys = [
-        'success', 'error', 'message', 'assets', 'folders', 'count', 'totalCount',
-        'saved', 'valid', 'issues', 'class', 'skeleton', 'parent',
-        'package', 'dependencies', 'graph', 'tags', 'metadata', 'properties'
-    ];
-    for (const key of usefulKeys) {
-        if (effectivePayload[key] !== undefined && effectivePayload[key] !== null) {
-            const val = effectivePayload[key];
-            if (typeof val === 'object') {
-                if (key === 'metadata' || key === 'properties' || key === 'tags') {
-                    const entries = Object.entries(val);
-                    const formatted = entries.map(([k, v]) => `${k}=${v}`);
-                    const limit = 50;
-                    parts.push(`${key}: { ${formatted.slice(0, limit).join(', ')}${formatted.length > limit ? '...' : ''} }`);
-                    continue;
+        if (isRecord(obj.result)) {
+            Object.assign(obj, obj.result);
+            delete obj.result;
+            flattenWrappers(obj, depth + 1);
+        }
+    };
+    flattenWrappers(effectivePayload);
+    const parts = [];
+    const addedKeys = new Set();
+    const skipKeys = new Set(['requestId', 'type', 'data', 'result', 'warnings']);
+    const formatValue = (val) => {
+        if (val === null || val === undefined)
+            return '';
+        if (typeof val === 'string')
+            return val.length > 150 ? val.slice(0, 150) + '...' : val;
+        if (typeof val === 'number' || typeof val === 'boolean')
+            return String(val);
+        if (Array.isArray(val)) {
+            if (val.length === 0)
+                return '[] (0)';
+            const items = val.slice(0, 30).map(v => {
+                if (isRecord(v)) {
+                    return v.name || v.path || v.id || v.nodeId || v.nodeName || v.className ||
+                        v.displayName || v.type || v.assetPath || v.objectPath ||
+                        JSON.stringify(v).slice(0, 50);
                 }
-                continue;
+                return String(v);
+            });
+            const suffix = val.length > 30 ? `, ... (+${val.length - 30} more)` : '';
+            return `[${items.join(', ')}${suffix}] (${val.length})`;
+        }
+        if (isRecord(val)) {
+            const keys = Object.keys(val);
+            if (keys.some(k => ['x', 'y', 'z', 'pitch', 'yaw', 'roll'].includes(k))) {
+                const x = val.x ?? val.pitch ?? 0;
+                const y = val.y ?? val.yaw ?? 0;
+                const z = val.z ?? val.roll ?? 0;
+                return `[${x}, ${y}, ${z}]`;
             }
-            const strVal = String(val);
-            if (strVal.length > 100)
-                continue;
-            if (!parts.some(p => p.includes(strVal))) {
-                parts.push(`${key}: ${strVal}`);
+            const entries = Object.entries(val).slice(0, 8);
+            const formatted = entries.map(([k, v]) => {
+                const vStr = typeof v === 'object' ? JSON.stringify(v).slice(0, 40) : String(v);
+                return `${k}=${vStr}`;
+            });
+            return `{ ${formatted.join(', ')}${keys.length > 8 ? ' ...' : ''} }`;
+        }
+        return String(val);
+    };
+    for (const key of ['success', 'error']) {
+        if (effectivePayload[key] !== undefined && !addedKeys.has(key)) {
+            const formatted = formatValue(effectivePayload[key]);
+            if (formatted) {
+                parts.push(`${key}: ${formatted}`);
+                addedKeys.add(key);
             }
         }
     }
-    const success = typeof payload.success === 'boolean' ? payload.success : undefined;
-    const message = typeof payload.message === 'string' ? normalizeText(payload.message) : '';
-    const error = typeof payload.error === 'string' ? normalizeText(payload.error) : '';
-    if (parts.length > 0) {
-        if (message && message.toLowerCase() !== 'success') {
-            parts.push(message);
+    let hasArrays = false;
+    for (const [key, val] of Object.entries(effectivePayload)) {
+        if (addedKeys.has(key))
+            continue;
+        if (skipKeys.has(key))
+            continue;
+        if (val === undefined || val === null)
+            continue;
+        if (typeof val === 'string' && val.trim() === '')
+            continue;
+        if (key === 'message')
+            continue;
+        if (Array.isArray(val) && val.length > 0)
+            hasArrays = true;
+        if ((key === 'count' || key === 'totalCount') && hasArrays)
+            continue;
+        const formatted = formatValue(val);
+        if (formatted) {
+            parts.push(`${key}: ${formatted}`);
+            addedKeys.add(key);
         }
     }
-    else {
-        if (message)
+    const message = typeof effectivePayload.message === 'string' ? normalizeText(effectivePayload.message) : '';
+    if (message && message.toLowerCase() !== 'success') {
+        const isDuplicateInfo = /^(found|listed|retrieved|got|loaded|created|deleted|saved|spawned)\s+\d+/i.test(message) ||
+            /Folders:\s*\[/.test(message) ||
+            /\d+\s+(assets?|folders?|items?|actors?|components?)\s+(and|in|at)/i.test(message);
+        const messageInParts = parts.some(p => p.toLowerCase().includes(message.toLowerCase().slice(0, 30)));
+        if (!isDuplicateInfo && !messageInParts) {
             parts.push(message);
-        if (error)
-            parts.push(`Error: ${error}`);
-        if (parts.length === 0 && success !== undefined) {
-            parts.push(success ? 'Success' : 'Failed');
         }
     }
-    const warnings = Array.isArray(payload.warnings) ? payload.warnings : [];
+    const warnings = Array.isArray(effectivePayload.warnings) ? effectivePayload.warnings : [];
     if (warnings.length > 0) {
-        parts.push(`Warnings: ${warnings.length}`);
+        parts.push(`Warnings: ${warnings.map((w) => typeof w === 'string' ? w : JSON.stringify(w)).join('; ')}`);
     }
     return parts.length > 0 ? parts.join(' | ') : `${toolName} responded`;
 }

package/dist/utils/unreal-command-queue.d.ts

@@ -11,6 +11,7 @@ export declare class UnrealCommandQueue {
     private isProcessing;
     private lastCommandTime;
     private lastStatCommandTime;
+    private processorInterval?;
     private readonly MIN_COMMAND_DELAY;
     private readonly MAX_COMMAND_DELAY;
     private readonly STAT_COMMAND_DELAY;
@@ -19,6 +20,7 @@ export declare class UnrealCommandQueue {
     private processQueue;
     private calculateDelay;
     private startProcessor;
+    stopProcessor(): void;
     private delay;
 }
 //# sourceMappingURL=unreal-command-queue.d.ts.map

package/dist/utils/unreal-command-queue.js

@@ -5,6 +5,7 @@ export class UnrealCommandQueue {
     isProcessing = false;
     lastCommandTime = 0;
     lastStatCommandTime = 0;
+    processorInterval;
     MIN_COMMAND_DELAY = 100;
     MAX_COMMAND_DELAY = 500;
     STAT_COMMAND_DELAY = 300;
@@ -107,12 +108,18 @@ export class UnrealCommandQueue {
         }
     }
     startProcessor() {
-        setInterval(() => {
+        this.processorInterval = setInterval(() => {
             if (!this.isProcessing && this.queue.length > 0) {
                 this.processQueue();
             }
         }, 1000);
     }
+    stopProcessor() {
+        if (this.processorInterval) {
+            clearInterval(this.processorInterval);
+            this.processorInterval = undefined;
+        }
+    }
     delay(ms) {
         return new Promise(resolve => setTimeout(resolve, ms));
     }

package/docs/Migration-Guide-v0.5.0.md

@@ -652,18 +652,10 @@ echo $WASM_ENABLED  # Should be "true"
 ### Documentation
 - [GraphQL API Documentation](GraphQL-API.md)
 - [WebAssembly Integration Guide](WebAssembly-Integration.md)
-- Added **GraphQL API** (optional) for complex queries.
-    - Disabled by default (`GRAPHQL_ENABLED=false`).
-    - Uses Apollo Server.
-    - Integrated with **Apollo Sandbox** (local IDE) or [Apollo Studio](https://studio.apollographql.com). - GraphQL platform
-- [Postman](https://www.postman.com/) - API testing
-
-### Learning
-- [GraphQL.org](https://graphql.org/) - Official GraphQL documentation
-- [WebAssembly.org](https://webassembly.org/) - WebAssembly specification
 
 ### Tools
 - [GraphiQL](https://github.com/graphql/graphiql) - In-browser GraphQL IDE
+- [Apollo Studio](https://studio.apollographql.com) - GraphQL platform
 - [Postman](https://www.postman.com/) - API testing
 
 ### Learning