unreal-engine-mcp-server 0.3.1 → 0.4.3

package/dist/types/index.d.ts

@@ -1,323 +0,0 @@
-/**
- * Comprehensive type definitions for Unreal Engine MCP Server
- */
-export * from './env.js';
-export * from './tool-types.js';
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface Rotation3 {
-    pitch: number;
-    yaw: number;
-    roll: number;
-}
-export interface Transform {
-    location: Vector3;
-    rotation: Rotation3;
-    scale?: Vector3;
-}
-export interface Color {
-    r: number;
-    g: number;
-    b: number;
-    a?: number;
-}
-export interface Asset {
-    Name: string;
-    Path: string;
-    Class: string;
-    PackagePath: string;
-    Type?: string;
-    Size?: number;
-    LastModified?: Date;
-}
-export interface Material extends Asset {
-    BaseColor?: Color;
-    Metallic?: number;
-    Roughness?: number;
-    Emissive?: Color;
-}
-export interface Texture extends Asset {
-    Width?: number;
-    Height?: number;
-    Format?: string;
-    MipLevels?: number;
-}
-export interface Actor {
-    Name: string;
-    Class: string;
-    Path: string;
-    Transform?: Transform;
-    Components?: Component[];
-    Tags?: string[];
-    IsSelected?: boolean;
-    IsHidden?: boolean;
-}
-export interface Component {
-    Name: string;
-    Class: string;
-    Properties?: Record<string, any>;
-}
-export interface Level {
-    Name: string;
-    Path: string;
-    IsLoaded: boolean;
-    IsVisible: boolean;
-    Actors?: Actor[];
-    StreamingLevels?: StreamingLevel[];
-}
-export interface StreamingLevel {
-    Name: string;
-    Path: string;
-    LoadingState: 'Unloaded' | 'Loading' | 'Loaded';
-    ShouldBeLoaded: boolean;
-    ShouldBeVisible: boolean;
-}
-export interface Blueprint {
-    Name: string;
-    Path: string;
-    ParentClass: string;
-    Components?: BlueprintComponent[];
-    Variables?: BlueprintVariable[];
-    Functions?: BlueprintFunction[];
-}
-export interface BlueprintComponent {
-    Name: string;
-    Type: string;
-    DefaultProperties?: Record<string, any>;
-}
-export interface BlueprintVariable {
-    Name: string;
-    Type: string;
-    DefaultValue?: any;
-    IsPublic?: boolean;
-    Category?: string;
-}
-export interface BlueprintFunction {
-    Name: string;
-    ReturnType?: string;
-    Parameters?: FunctionParameter[];
-    IsPublic?: boolean;
-}
-export interface FunctionParameter {
-    Name: string;
-    Type: string;
-    DefaultValue?: any;
-    IsOptional?: boolean;
-}
-export interface AnimationSequence {
-    Name: string;
-    Path: string;
-    Duration: number;
-    FrameRate: number;
-    Skeleton?: string;
-}
-export interface AnimationMontage {
-    Name: string;
-    Path: string;
-    Sections?: MontageSection[];
-    BlendIn?: number;
-    BlendOut?: number;
-}
-export interface MontageSection {
-    Name: string;
-    StartTime: number;
-    EndTime: number;
-    NextSection?: string;
-}
-export interface PhysicsBody {
-    Mass: number;
-    LinearDamping: number;
-    AngularDamping: number;
-    EnableGravity: boolean;
-    IsKinematic: boolean;
-    CollisionEnabled: boolean;
-}
-export interface PhysicsConstraint {
-    Name: string;
-    Actor1: string;
-    Actor2: string;
-    LinearLimits?: Vector3;
-    AngularLimits?: Vector3;
-}
-export interface NiagaraSystem {
-    Name: string;
-    Path: string;
-    Emitters?: NiagaraEmitter[];
-    Parameters?: NiagaraParameter[];
-}
-export interface NiagaraEmitter {
-    Name: string;
-    SpawnRate: number;
-    Lifetime: number;
-    VelocityModule?: Vector3;
-    ColorModule?: Color;
-}
-export interface NiagaraParameter {
-    Name: string;
-    Type: string;
-    Value: any;
-}
-export interface Landscape {
-    Name: string;
-    ComponentCount: number;
-    Resolution: {
-        x: number;
-        y: number;
-    };
-    Scale: Vector3;
-    Materials?: string[];
-    Layers?: LandscapeLayer[];
-}
-export interface LandscapeLayer {
-    Name: string;
-    BlendMode: string;
-    Weight: number;
-}
-export interface RemoteControlPreset {
-    Name: string;
-    Path: string;
-    ExposedProperties?: ExposedProperty[];
-    ExposedFunctions?: ExposedFunction[];
-}
-export interface ExposedProperty {
-    Name: string;
-    DisplayName?: string;
-    ObjectPath: string;
-    PropertyPath: string;
-    Type: string;
-    Value?: any;
-    Metadata?: Record<string, any>;
-}
-export interface ExposedFunction {
-    Name: string;
-    DisplayName?: string;
-    ObjectPath: string;
-    FunctionName: string;
-    Parameters?: FunctionParameter[];
-}
-export interface LevelSequence {
-    Name: string;
-    Path: string;
-    Duration: number;
-    FrameRate: number;
-    Tracks?: SequencerTrack[];
-}
-export interface SequencerTrack {
-    Name: string;
-    Type: string;
-    BoundObject?: string;
-    Sections?: SequencerSection[];
-}
-export interface SequencerSection {
-    StartFrame: number;
-    EndFrame: number;
-    Properties?: Record<string, any>;
-}
-export interface PerformanceMetrics {
-    FPS: number;
-    FrameTime: number;
-    GameThreadTime: number;
-    RenderThreadTime: number;
-    GPUTime: number;
-    DrawCalls: number;
-    Triangles: number;
-    Memory: MemoryMetrics;
-}
-export interface MemoryMetrics {
-    Physical: number;
-    Virtual: number;
-    GPU: number;
-    TextureMemory: number;
-    MeshMemory: number;
-}
-export interface EngineVersion {
-    Major: number;
-    Minor: number;
-    Patch: number;
-    Build?: number;
-    Branch?: string;
-    Compatible?: boolean;
-}
-export interface ProjectInfo {
-    Name: string;
-    Path: string;
-    EngineVersion: string;
-    Plugins?: PluginInfo[];
-    Settings?: ProjectSettings;
-}
-export interface PluginInfo {
-    Name: string;
-    Version: string;
-    Enabled: boolean;
-    Category?: string;
-}
-export interface ProjectSettings {
-    DefaultMap?: string;
-    DefaultGameMode?: string;
-    TargetFrameRate?: number;
-    EnableRayTracing?: boolean;
-    EnableNanite?: boolean;
-}
-export interface SuccessResponse<T = any> {
-    success: true;
-    data?: T;
-    message?: string;
-    metadata?: Record<string, any>;
-}
-export interface ErrorResponse {
-    success: false;
-    error: string;
-    code?: string;
-    statusCode?: number;
-    details?: Record<string, any>;
-}
-export type ApiResponse<T = any> = SuccessResponse<T> | ErrorResponse;
-export interface ToolContext {
-    bridge: any;
-    tools: Record<string, any>;
-    cache?: any;
-    metrics?: any;
-}
-export interface ToolResult<T = any> {
-    content: Array<{
-        type: 'text' | 'json' | 'error';
-        text?: string;
-        data?: T;
-    }>;
-    isError?: boolean;
-    metadata?: Record<string, any>;
-}
-export interface UnrealEvent {
-    type: string;
-    timestamp: Date;
-    data: any;
-    source?: string;
-}
-export interface PropertyChangeEvent extends UnrealEvent {
-    type: 'property_change';
-    objectPath: string;
-    propertyName: string;
-    oldValue: any;
-    newValue: any;
-}
-export interface ActorSpawnEvent extends UnrealEvent {
-    type: 'actor_spawn';
-    actorName: string;
-    actorClass: string;
-    location: Vector3;
-}
-export type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-export type Nullable<T> = T | null;
-export type Optional<T> = T | undefined;
-export type AsyncResult<T> = Promise<ApiResponse<T>>;
-export type Callback<T> = (error: Error | null, result?: T) => void;
-export declare function isVector3(value: any): value is Vector3;
-export declare function isRotation3(value: any): value is Rotation3;
-export declare function isSuccessResponse<T>(response: ApiResponse<T>): response is SuccessResponse<T>;
-export declare function isErrorResponse(response: ApiResponse): response is ErrorResponse;
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -1,28 +0,0 @@
-/**
- * Comprehensive type definitions for Unreal Engine MCP Server
- */
-// Re-export existing types
-export * from './env.js';
-export * from './tool-types.js';
-// Type guards
-export function isVector3(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.x === 'number' &&
-        typeof value.y === 'number' &&
-        typeof value.z === 'number');
-}
-export function isRotation3(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        typeof value.pitch === 'number' &&
-        typeof value.yaw === 'number' &&
-        typeof value.roll === 'number');
-}
-export function isSuccessResponse(response) {
-    return response.success === true;
-}
-export function isErrorResponse(response) {
-    return response.success === false;
-}
-//# sourceMappingURL=index.js.map

package/dist/utils/cache-manager.d.ts

@@ -1,64 +0,0 @@
-/**
- * Cache Manager for API responses
- * Implements LRU cache with TTL support for optimizing repeated API calls
- */
-interface CacheOptions {
-    maxSize?: number;
-    defaultTTL?: number;
-    enableMetrics?: boolean;
-}
-interface CacheMetrics {
-    hits: number;
-    misses: number;
-    evictions: number;
-    size: number;
-}
-export declare class CacheManager<T = any> {
-    private cache;
-    private readonly maxSize;
-    private readonly defaultTTL;
-    private readonly enableMetrics;
-    private metrics;
-    constructor(options?: CacheOptions);
-    /**
-     * Get item from cache
-     */
-    get(key: string): T | null;
-    /**
-     * Set item in cache
-     */
-    set(key: string, data: T): void;
-    /**
-     * Check if key exists and is valid
-     */
-    has(key: string): boolean;
-    /**
-     * Clear specific key or all cache
-     */
-    clear(key?: string): void;
-    /**
-     * Get cache metrics
-     */
-    getMetrics(): CacheMetrics;
-    /**
-     * Get cache hit rate
-     */
-    getHitRate(): number;
-    /**
-     * Wrap async function with cache
-     */
-    wrap<R = T>(key: string, fn: () => Promise<R>): Promise<R>;
-    /**
-     * Batch get multiple keys
-     */
-    getBatch(keys: string[]): Map<string, T | null>;
-    /**
-     * Invalidate cache entries by pattern
-     */
-    invalidatePattern(pattern: RegExp): number;
-}
-export declare const assetCache: CacheManager<any>;
-export declare const engineCache: CacheManager<any>;
-export declare const commandCache: CacheManager<any>;
-export {};
-//# sourceMappingURL=cache-manager.d.ts.map

package/dist/utils/cache-manager.js

@@ -1,176 +0,0 @@
-/**
- * Cache Manager for API responses
- * Implements LRU cache with TTL support for optimizing repeated API calls
- */
-export class CacheManager {
-    cache;
-    maxSize;
-    defaultTTL;
-    enableMetrics;
-    metrics;
-    constructor(options = {}) {
-        this.cache = new Map();
-        this.maxSize = options.maxSize || 100;
-        this.defaultTTL = options.defaultTTL || 60000; // 1 minute default
-        this.enableMetrics = options.enableMetrics || false;
-        this.metrics = {
-            hits: 0,
-            misses: 0,
-            evictions: 0,
-            size: 0
-        };
-    }
-    /**
-     * Get item from cache
-     */
-    get(key) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            if (this.enableMetrics)
-                this.metrics.misses++;
-            return null;
-        }
-        // Check if expired
-        if (Date.now() - entry.timestamp > this.defaultTTL) {
-            this.cache.delete(key);
-            if (this.enableMetrics) {
-                this.metrics.misses++;
-                this.metrics.size--;
-            }
-            return null;
-        }
-        // Update hit count and move to end (LRU)
-        entry.hits++;
-        this.cache.delete(key);
-        this.cache.set(key, entry);
-        if (this.enableMetrics)
-            this.metrics.hits++;
-        return entry.data;
-    }
-    /**
-     * Set item in cache
-     */
-    set(key, data) {
-        // Evict oldest if at max size
-        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey) {
-                this.cache.delete(firstKey);
-                if (this.enableMetrics) {
-                    this.metrics.evictions++;
-                    this.metrics.size--;
-                }
-            }
-        }
-        const entry = {
-            data,
-            timestamp: Date.now(),
-            hits: 0
-        };
-        this.cache.set(key, entry);
-        if (this.enableMetrics)
-            this.metrics.size = this.cache.size;
-    }
-    /**
-     * Check if key exists and is valid
-     */
-    has(key) {
-        const entry = this.cache.get(key);
-        if (!entry)
-            return false;
-        // Check expiration
-        if (Date.now() - entry.timestamp > this.defaultTTL) {
-            this.cache.delete(key);
-            if (this.enableMetrics)
-                this.metrics.size--;
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Clear specific key or all cache
-     */
-    clear(key) {
-        if (key) {
-            this.cache.delete(key);
-            if (this.enableMetrics)
-                this.metrics.size = this.cache.size;
-        }
-        else {
-            this.cache.clear();
-            if (this.enableMetrics) {
-                this.metrics.size = 0;
-            }
-        }
-    }
-    /**
-     * Get cache metrics
-     */
-    getMetrics() {
-        return { ...this.metrics };
-    }
-    /**
-     * Get cache hit rate
-     */
-    getHitRate() {
-        const total = this.metrics.hits + this.metrics.misses;
-        return total > 0 ? this.metrics.hits / total : 0;
-    }
-    /**
-     * Wrap async function with cache
-     */
-    async wrap(key, fn) {
-        // Check cache first
-        const cached = this.get(key);
-        if (cached !== null) {
-            return cached;
-        }
-        // Execute function and cache result
-        const result = await fn();
-        this.set(key, result);
-        return result;
-    }
-    /**
-     * Batch get multiple keys
-     */
-    getBatch(keys) {
-        const results = new Map();
-        for (const key of keys) {
-            results.set(key, this.get(key));
-        }
-        return results;
-    }
-    /**
-     * Invalidate cache entries by pattern
-     */
-    invalidatePattern(pattern) {
-        let count = 0;
-        for (const key of this.cache.keys()) {
-            if (pattern.test(key)) {
-                this.cache.delete(key);
-                count++;
-            }
-        }
-        if (this.enableMetrics) {
-            this.metrics.size = this.cache.size;
-        }
-        return count;
-    }
-}
-// Global cache instances for different purposes
-export const assetCache = new CacheManager({
-    maxSize: 500,
-    defaultTTL: 300000, // 5 minutes for assets
-    enableMetrics: true
-});
-export const engineCache = new CacheManager({
-    maxSize: 50,
-    defaultTTL: 600000, // 10 minutes for engine info
-    enableMetrics: true
-});
-export const commandCache = new CacheManager({
-    maxSize: 100,
-    defaultTTL: 30000, // 30 seconds for commands
-    enableMetrics: true
-});
-//# sourceMappingURL=cache-manager.js.map

package/dist/utils/errors.d.ts

@@ -1,133 +0,0 @@
-/**
- * Enhanced error types for better error handling and recovery
- */
-export declare enum ErrorCode {
-    CONNECTION_FAILED = "CONNECTION_FAILED",
-    CONNECTION_TIMEOUT = "CONNECTION_TIMEOUT",
-    CONNECTION_REFUSED = "CONNECTION_REFUSED",
-    API_ERROR = "API_ERROR",
-    INVALID_RESPONSE = "INVALID_RESPONSE",
-    RATE_LIMITED = "RATE_LIMITED",
-    VALIDATION_ERROR = "VALIDATION_ERROR",
-    INVALID_PARAMETERS = "INVALID_PARAMETERS",
-    MISSING_REQUIRED_FIELD = "MISSING_REQUIRED_FIELD",
-    RESOURCE_NOT_FOUND = "RESOURCE_NOT_FOUND",
-    RESOURCE_LOCKED = "RESOURCE_LOCKED",
-    RESOURCE_UNAVAILABLE = "RESOURCE_UNAVAILABLE",
-    UNAUTHORIZED = "UNAUTHORIZED",
-    FORBIDDEN = "FORBIDDEN",
-    INTERNAL_ERROR = "INTERNAL_ERROR",
-    CIRCUIT_BREAKER_OPEN = "CIRCUIT_BREAKER_OPEN",
-    SERVICE_UNAVAILABLE = "SERVICE_UNAVAILABLE"
-}
-export interface ErrorMetadata {
-    code: ErrorCode;
-    statusCode?: number;
-    retriable: boolean;
-    context?: Record<string, any>;
-    timestamp: Date;
-    correlationId?: string;
-}
-/**
- * Base application error with metadata
- */
-export declare class AppError extends Error {
-    readonly metadata: ErrorMetadata;
-    constructor(message: string, metadata?: Partial<ErrorMetadata>);
-    toJSON(): {
-        stack: string | undefined;
-        code: ErrorCode;
-        statusCode?: number;
-        retriable: boolean;
-        context?: Record<string, any>;
-        timestamp: Date;
-        correlationId?: string;
-        name: string;
-        message: string;
-    };
-}
-/**
- * Connection-related errors
- */
-export declare class ConnectionError extends AppError {
-    constructor(message: string, metadata?: Partial<ErrorMetadata>);
-}
-/**
- * API-related errors
- */
-export declare class ApiError extends AppError {
-    constructor(message: string, statusCode: number, metadata?: Partial<ErrorMetadata>);
-}
-/**
- * Validation errors
- */
-export declare class ValidationError extends AppError {
-    constructor(message: string, metadata?: Partial<ErrorMetadata>);
-}
-/**
- * Resource errors
- */
-export declare class ResourceError extends AppError {
-    constructor(message: string, code: ErrorCode, metadata?: Partial<ErrorMetadata>);
-}
-/**
- * Circuit Breaker implementation for fault tolerance
- */
-export declare enum CircuitState {
-    CLOSED = "CLOSED",
-    OPEN = "OPEN",
-    HALF_OPEN = "HALF_OPEN"
-}
-interface CircuitBreakerOptions {
-    threshold: number;
-    timeout: number;
-    resetTimeout: number;
-    onStateChange?: (oldState: CircuitState, newState: CircuitState) => void;
-}
-export declare class CircuitBreaker {
-    private state;
-    private failures;
-    private successCount;
-    private lastFailureTime?;
-    private readonly options;
-    constructor(options?: Partial<CircuitBreakerOptions>);
-    /**
-     * Execute function with circuit breaker protection
-     */
-    execute<T>(fn: () => Promise<T>): Promise<T>;
-    private onSuccess;
-    private onFailure;
-    private shouldAttemptReset;
-    private transitionTo;
-    getState(): CircuitState;
-    getMetrics(): {
-        state: CircuitState;
-        failures: number;
-        successCount: number;
-        lastFailureTime: Date | undefined;
-    };
-}
-/**
- * Error recovery strategies
- */
-export declare class ErrorRecovery {
-    private static circuitBreakers;
-    /**
-     * Get or create circuit breaker for a service
-     */
-    static getCircuitBreaker(service: string, options?: Partial<CircuitBreakerOptions>): CircuitBreaker;
-    /**
-     * Wrap function with error recovery
-     */
-    static withRecovery<T>(fn: () => Promise<T>, options: {
-        service: string;
-        fallback?: () => T | Promise<T>;
-        onError?: (error: Error) => void;
-    }): Promise<T>;
-    /**
-     * Check if error is retriable
-     */
-    static isRetriable(error: Error): boolean;
-}
-export {};
-//# sourceMappingURL=errors.d.ts.map