unreal-engine-mcp-server 0.2.1

package/dist/types/index.d.ts

@@ -0,0 +1,323 @@
+/**
+ * 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

@@ -0,0 +1,28 @@
+/**
+ * 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/types/tool-types.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Auto-generated TypeScript types from tool schemas
+ * This provides type safety and IntelliSense support
+ */
+export interface BaseToolResponse {
+    success: boolean;
+    message?: string;
+    error?: string;
+    warning?: string;
+}
+export interface AssetInfo {
+    Name: string;
+    Path: string;
+    Class?: string;
+    PackagePath?: string;
+}
+export interface ManageAssetResponse extends BaseToolResponse {
+    assets?: AssetInfo[];
+    paths?: string[];
+    materialPath?: string;
+}
+export interface Vector3D {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Rotation3D {
+    pitch: number;
+    yaw: number;
+    roll: number;
+}
+export interface ControlActorResponse extends BaseToolResponse {
+    actor?: string;
+    deleted?: string;
+    physicsEnabled?: boolean;
+}
+export interface ControlEditorResponse extends BaseToolResponse {
+    playing?: boolean;
+    location?: [number, number, number];
+    rotation?: [number, number, number];
+    viewMode?: string;
+}
+export interface ManageLevelResponse extends BaseToolResponse {
+    levelName?: string;
+    loaded?: boolean;
+    visible?: boolean;
+    lightName?: string;
+    buildQuality?: string;
+}
+export interface AnimationPhysicsResponse extends BaseToolResponse {
+    blueprintPath?: string;
+    playing?: boolean;
+    playRate?: number;
+    ragdollActive?: boolean;
+}
+export interface CreateEffectResponse extends BaseToolResponse {
+    effectName?: string;
+    effectPath?: string;
+    spawned?: boolean;
+    location?: [number, number, number];
+}
+export interface ManageBlueprintResponse extends BaseToolResponse {
+    blueprintPath?: string;
+    componentAdded?: string;
+}
+export interface BuildEnvironmentResponse extends BaseToolResponse {
+    landscapeName?: string;
+    foliageTypeName?: string;
+    instancesPlaced?: number;
+}
+export interface SystemControlResponse extends BaseToolResponse {
+    profiling?: boolean;
+    fpsVisible?: boolean;
+    qualityLevel?: number;
+    soundPlaying?: boolean;
+    widgetPath?: string;
+    widgetVisible?: boolean;
+}
+export interface ConsoleCommandResponse extends BaseToolResponse {
+    command?: string;
+    result?: any;
+    info?: string;
+}
+export interface VerifyEnvironmentResponse extends BaseToolResponse {
+    exists?: boolean;
+    count?: number;
+    actual?: number;
+    method?: string;
+}
+export interface ToolParameters {
+    ListAssetsParams: {
+        directory: string;
+        recursive?: boolean;
+    };
+    ImportAssetParams: {
+        sourcePath: string;
+        destinationPath: string;
+    };
+    CreateMaterialParams: {
+        name: string;
+        path: string;
+    };
+    SpawnActorParams: {
+        classPath: string;
+        location?: Vector3D;
+        rotation?: Rotation3D;
+    };
+    DeleteActorParams: {
+        actorName: string;
+    };
+    ApplyForceParams: {
+        actorName: string;
+        force: Vector3D;
+    };
+    SetCameraParams: {
+        location?: Vector3D;
+        rotation?: Rotation3D;
+    };
+    SetViewModeParams: {
+        mode: string;
+    };
+    ConsoleCommandParams: {
+        command: string;
+    };
+}
+export type AssetAction = 'list' | 'import' | 'create_material';
+export type ActorAction = 'spawn' | 'delete' | 'apply_force';
+export type EditorAction = 'play' | 'stop' | 'set_camera' | 'set_view_mode';
+export type LevelAction = 'load' | 'save' | 'stream' | 'create_light' | 'build_lighting';
+export type AnimationAction = 'create_animation_bp' | 'play_montage' | 'setup_ragdoll';
+export type EffectAction = 'particle' | 'niagara' | 'debug_shape';
+export type BlueprintAction = 'create' | 'add_component';
+export type EnvironmentAction = 'create_landscape' | 'sculpt' | 'add_foliage' | 'paint_foliage';
+export type SystemAction = 'profile' | 'show_fps' | 'set_quality' | 'play_sound' | 'create_widget' | 'show_widget';
+export type VerificationAction = 'foliage_type_exists' | 'foliage_instances_near' | 'landscape_exists' | 'quality_level';
+export interface ConsolidatedToolParams {
+    manage_asset: {
+        action: AssetAction;
+        directory?: string;
+        recursive?: boolean;
+        sourcePath?: string;
+        destinationPath?: string;
+        name?: string;
+        path?: string;
+    };
+    control_actor: {
+        action: ActorAction;
+        actorName?: string;
+        classPath?: string;
+        location?: Vector3D;
+        rotation?: Rotation3D;
+        force?: Vector3D;
+    };
+    control_editor: {
+        action: EditorAction;
+        location?: Vector3D;
+        rotation?: Rotation3D;
+        viewMode?: string;
+    };
+    manage_level: {
+        action: LevelAction;
+        levelPath?: string;
+        levelName?: string;
+        streaming?: boolean;
+        shouldBeLoaded?: boolean;
+        shouldBeVisible?: boolean;
+        lightType?: 'Directional' | 'Point' | 'Spot' | 'Rect';
+        name?: string;
+        location?: Vector3D;
+        intensity?: number;
+        quality?: 'Preview' | 'Medium' | 'High' | 'Production';
+    };
+    animation_physics: {
+        action: AnimationAction;
+        name?: string;
+        actorName?: string;
+        skeletonPath?: string;
+        montagePath?: string;
+        animationPath?: string;
+        playRate?: number;
+        physicsAssetName?: string;
+        blendWeight?: number;
+        savePath?: string;
+    };
+    create_effect: {
+        action: EffectAction;
+        name?: string;
+        location?: Vector3D;
+        effectType?: string;
+        systemPath?: string;
+        scale?: number;
+        shape?: string;
+        size?: number;
+        color?: [number, number, number, number];
+        duration?: number;
+    };
+    manage_blueprint: {
+        action: BlueprintAction;
+        name: string;
+        blueprintType?: string;
+        componentType?: string;
+        componentName?: string;
+        savePath?: string;
+    };
+    build_environment: {
+        action: EnvironmentAction;
+        name?: string;
+        sizeX?: number;
+        sizeY?: number;
+        tool?: string;
+        meshPath?: string;
+        foliageType?: string;
+        density?: number;
+        position?: Vector3D;
+        brushSize?: number;
+        strength?: number;
+    };
+    system_control: {
+        action: SystemAction;
+        profileType?: string;
+        category?: string;
+        level?: number;
+        enabled?: boolean;
+        verbose?: boolean;
+        soundPath?: string;
+        location?: Vector3D;
+        volume?: number;
+        is3D?: boolean;
+        widgetName?: string;
+        widgetType?: string;
+        visible?: boolean;
+    };
+    console_command: {
+        command: string;
+    };
+    verify_environment: {
+        action: VerificationAction;
+        name?: string;
+        position?: Vector3D;
+        radius?: number;
+        category?: string;
+    };
+}
+export interface ToolResponseMap {
+    manage_asset: ManageAssetResponse;
+    control_actor: ControlActorResponse;
+    control_editor: ControlEditorResponse;
+    manage_level: ManageLevelResponse;
+    animation_physics: AnimationPhysicsResponse;
+    create_effect: CreateEffectResponse;
+    manage_blueprint: ManageBlueprintResponse;
+    build_environment: BuildEnvironmentResponse;
+    system_control: SystemControlResponse;
+    console_command: ConsoleCommandResponse;
+    verify_environment: VerifyEnvironmentResponse;
+    list_assets: ManageAssetResponse;
+    import_asset: ManageAssetResponse;
+    spawn_actor: ControlActorResponse;
+    delete_actor: ControlActorResponse;
+    create_material: ManageAssetResponse;
+    play_in_editor: ControlEditorResponse;
+    stop_play_in_editor: ControlEditorResponse;
+    set_camera: ControlEditorResponse;
+}
+export type ToolName = keyof ToolResponseMap;
+export type GetToolResponse<T extends ToolName> = ToolResponseMap[T];
+export type GetToolParams<T extends keyof ConsolidatedToolParams> = ConsolidatedToolParams[T];
+export declare function isSuccessResponse(response: BaseToolResponse): response is BaseToolResponse & {
+    success: true;
+};
+export declare function isErrorResponse(response: BaseToolResponse): response is BaseToolResponse & {
+    error: string;
+};
+//# sourceMappingURL=tool-types.d.ts.map

package/dist/types/tool-types.js

@@ -0,0 +1,13 @@
+/**
+ * Auto-generated TypeScript types from tool schemas
+ * This provides type safety and IntelliSense support
+ */
+// Export a type guard to check if a response is successful
+export function isSuccessResponse(response) {
+    return response.success === true;
+}
+// Export a type guard to check if a response has an error
+export function isErrorResponse(response) {
+    return response.success === false && typeof response.error === 'string';
+}
+//# sourceMappingURL=tool-types.js.map