unreal-engine-mcp-server 0.5.4 → 0.5.5

package/src/automation/connection-manager.ts

@@ -1,148 +0,0 @@
-import { WebSocket } from 'ws';
-import { Logger } from '../utils/logger.js';
-import { randomUUID } from 'node:crypto';
-import { SocketInfo } from './types.js';
-import { EventEmitter } from 'node:events';
-
-export class ConnectionManager extends EventEmitter {
-    private activeSockets = new Map<WebSocket, SocketInfo>();
-    private primarySocket?: WebSocket;
-    private heartbeatTimer?: NodeJS.Timeout;
-    private lastMessageAt?: Date;
-    private log = new Logger('ConnectionManager');
-
-    constructor(
-        private heartbeatIntervalMs: number
-    ) {
-        super();
-    }
-
-    /**
-     * Get the configured heartbeat interval in milliseconds.
-     * @returns The heartbeat interval or 0 if disabled
-     */
-    public getHeartbeatIntervalMs(): number {
-        return this.heartbeatIntervalMs;
-    }
-
-    public registerSocket(
-        socket: WebSocket,
-        port: number,
-        metadata?: Record<string, unknown>,
-        remoteAddress?: string,
-        remotePort?: number
-    ): void {
-        const connectionId = randomUUID();
-        const sessionId = metadata && typeof metadata.sessionId === 'string' ? (metadata.sessionId as string) : undefined;
-        const socketInfo: SocketInfo = {
-            connectionId,
-            port,
-            connectedAt: new Date(),
-            protocol: socket.protocol || undefined,
-            sessionId,
-            remoteAddress: remoteAddress ?? undefined,
-            remotePort: typeof remotePort === 'number' ? remotePort : undefined
-        };
-
-        this.activeSockets.set(socket, socketInfo);
-
-        // Set as primary socket if this is the first connection
-        if (!this.primarySocket) {
-            this.primarySocket = socket;
-        }
-
-        // Handle WebSocket pong frames for heartbeat tracking
-        socket.on('pong', () => {
-            this.lastMessageAt = new Date();
-        });
-
-        // Auto-cleanup on close or error
-        socket.once('close', () => {
-            this.removeSocket(socket);
-        });
-
-        socket.once('error', (error) => {
-            this.log.error('Socket error in ConnectionManager', error);
-            this.removeSocket(socket);
-        });
-    }
-
-    public removeSocket(socket: WebSocket): SocketInfo | undefined {
-        const info = this.activeSockets.get(socket);
-        if (info) {
-            this.activeSockets.delete(socket);
-            if (socket === this.primarySocket) {
-                this.primarySocket = this.activeSockets.size > 0 ? this.activeSockets.keys().next().value : undefined;
-                if (this.activeSockets.size === 0) {
-                    this.stopHeartbeat();
-                }
-            }
-        }
-        return info;
-    }
-
-    public getActiveSockets(): Map<WebSocket, SocketInfo> {
-        return this.activeSockets;
-    }
-
-    public getPrimarySocket(): WebSocket | undefined {
-        return this.primarySocket;
-    }
-
-    public isConnected(): boolean {
-        return this.activeSockets.size > 0;
-    }
-
-    public startHeartbeat(): void {
-        if (this.heartbeatIntervalMs <= 0) return;
-        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-
-        this.heartbeatTimer = setInterval(() => {
-            if (this.activeSockets.size === 0) {
-                this.stopHeartbeat();
-                return;
-            }
-
-            const pingPayload = JSON.stringify({
-                type: 'bridge_ping',
-                timestamp: new Date().toISOString()
-            });
-
-            for (const [socket] of this.activeSockets) {
-                if (socket.readyState === WebSocket.OPEN) {
-                    try {
-                        socket.ping();
-                        socket.send(pingPayload);
-                    } catch (error) {
-                        this.log.error('Failed to send heartbeat', error);
-                    }
-                }
-            }
-        }, this.heartbeatIntervalMs);
-    }
-
-    public stopHeartbeat(): void {
-        if (this.heartbeatTimer) {
-            clearInterval(this.heartbeatTimer);
-            this.heartbeatTimer = undefined;
-        }
-    }
-
-    public updateLastMessageTime(): void {
-        this.lastMessageAt = new Date();
-    }
-
-    public getLastMessageTime(): Date | undefined {
-        return this.lastMessageAt;
-    }
-
-    public closeAll(code?: number, reason?: string): void {
-        this.stopHeartbeat();
-        for (const [socket] of this.activeSockets) {
-            socket.removeAllListeners();
-            socket.close(code, reason);
-        }
-        this.activeSockets.clear();
-        this.primarySocket = undefined;
-    }
-}

package/src/automation/handshake.ts

@@ -1,99 +0,0 @@
-import { WebSocket } from 'ws';
-import { Logger } from '../utils/logger.js';
-import { AutomationBridgeMessage } from './types.js';
-import { EventEmitter } from 'node:events';
-
-export class HandshakeHandler extends EventEmitter {
-    private log = new Logger('HandshakeHandler');
-    private readonly DEFAULT_HANDSHAKE_TIMEOUT_MS = 5000;
-
-    constructor(
-        private capabilityToken?: string
-    ) {
-        super();
-    }
-
-    public initiateHandshake(socket: WebSocket, timeoutMs: number = this.DEFAULT_HANDSHAKE_TIMEOUT_MS): Promise<Record<string, unknown>> {
-        return new Promise((resolve, reject) => {
-            let handshakeComplete = false;
-
-            const timeout = setTimeout(() => {
-                if (!handshakeComplete) {
-                    this.log.warn('Automation bridge client handshake timed out');
-                    socket.close(4002, 'Handshake timeout');
-                    reject(new Error('Handshake timeout'));
-                }
-            }, timeoutMs);
-
-            const onMessage = (data: any) => {
-                let parsed: AutomationBridgeMessage;
-                const text = typeof data === 'string' ? data : data.toString('utf8');
-                try {
-                    parsed = JSON.parse(text) as AutomationBridgeMessage;
-                } catch (error) {
-                    this.log.error('Received non-JSON automation message during handshake', error);
-                    socket.close(4003, 'Invalid JSON payload');
-                    cleanup();
-                    reject(new Error('Invalid JSON payload'));
-                    return;
-                }
-
-                if (parsed.type === 'bridge_ack') {
-                    handshakeComplete = true;
-                    cleanup();
-                    const metadata = this.sanitizeHandshakeMetadata(parsed as Record<string, unknown>);
-                    resolve(metadata);
-                } else {
-                    this.log.warn(`Expected bridge_ack handshake, received ${parsed.type}`);
-                    socket.close(4004, 'Handshake expected bridge_ack');
-                    cleanup();
-                    reject(new Error(`Handshake expected bridge_ack, got ${parsed.type}`));
-                }
-            };
-
-            const onError = (error: Error) => {
-                cleanup();
-                reject(error);
-            };
-
-            const onClose = () => {
-                cleanup();
-                reject(new Error('Socket closed during handshake'));
-            };
-
-            const cleanup = () => {
-                clearTimeout(timeout);
-                socket.off('message', onMessage);
-                socket.off('error', onError);
-                socket.off('close', onClose);
-            };
-
-            socket.on('message', onMessage);
-            socket.on('error', onError);
-            socket.on('close', onClose);
-
-            // Send bridge_hello with a slight delay to ensure the server has registered its handlers
-            setTimeout(() => {
-                if (socket.readyState === WebSocket.OPEN) {
-                    const helloPayload: AutomationBridgeMessage = {
-                        type: 'bridge_hello',
-                        capabilityToken: this.capabilityToken || undefined
-                    };
-                    this.log.debug(`Sending bridge_hello (delayed): ${JSON.stringify(helloPayload)}`);
-                    socket.send(JSON.stringify(helloPayload));
-                } else {
-                    this.log.warn('Socket closed before bridge_hello could be sent');
-                }
-            }, 500);
-        });
-    }
-
-    private sanitizeHandshakeMetadata(payload: Record<string, unknown>): Record<string, unknown> {
-        const sanitized: Record<string, unknown> = { ...payload };
-        delete sanitized.type;
-        if ('capabilityToken' in sanitized) {
-            sanitized.capabilityToken = 'REDACTED';
-        }
-        return sanitized;
-    }
-}

package/src/automation/index.ts

@@ -1,2 +0,0 @@
-export { AutomationBridge } from './bridge.js';
-export * from './types.js';

package/src/automation/message-handler.ts

@@ -1,192 +0,0 @@
-import { Logger } from '../utils/logger.js';
-import { AutomationBridgeMessage, AutomationBridgeResponseMessage } from './types.js';
-import { RequestTracker } from './request-tracker.js';
-
-function FStringSafe(val: unknown): string {
-    try {
-        if (val === undefined || val === null) return '';
-        if (typeof val === 'string') return val;
-        return JSON.stringify(val);
-    } catch {
-        try { return String(val); } catch { return ''; }
-    }
-}
-
-/** Response result with optional saved flag */
-interface ResponseResult {
-    saved?: boolean;
-    action?: string;
-    success?: boolean;
-    message?: string;
-    error?: string;
-    [key: string]: unknown;
-}
-
-/** Event message structure */
-interface EventMessage extends AutomationBridgeMessage {
-    requestId?: string;
-    event?: string;
-    payload?: unknown;
-    result?: ResponseResult;
-    message?: string;
-}
-
-/** Response with optional action field */
-interface ResponseWithAction extends AutomationBridgeResponseMessage {
-    action?: string;
-}
-
-export class MessageHandler {
-    private log = new Logger('MessageHandler');
-
-    constructor(
-        private requestTracker: RequestTracker
-    ) { }
-
-    public handleMessage(message: AutomationBridgeMessage): void {
-        switch (message.type) {
-            case 'automation_response':
-                this.handleAutomationResponse(message as AutomationBridgeResponseMessage);
-                break;
-            case 'bridge_ping':
-                // Handled by connection manager or ignored if client
-                break;
-            case 'bridge_pong':
-                // Handled by connection manager
-                break;
-            case 'bridge_goodbye':
-                this.log.info('Automation bridge client initiated shutdown.', message);
-                break;
-            case 'automation_event':
-                this.handleAutomationEvent(message);
-                break;
-            default:
-                this.log.debug('Received automation bridge message with no handler', message);
-                break;
-        }
-    }
-
-    private handleAutomationResponse(response: AutomationBridgeResponseMessage): void {
-        const requestId = response.requestId;
-        if (!requestId) {
-            this.log.warn('Received automation_response without requestId');
-            return;
-        }
-
-        const pending = this.requestTracker.getPendingRequest(requestId);
-        if (!pending) {
-            this.log.debug(`No pending automation request found for requestId=${requestId}`);
-            return;
-        }
-
-        // Enforce action match logic
-        const enforcedResponse = this.enforceActionMatch(response, pending.action);
-
-        if (pending.waitForEvent) {
-            if (!pending.initialResponse) {
-                // Store initial response and wait for event
-                pending.initialResponse = enforcedResponse;
-
-                // If the initial response indicates failure, resolve immediately
-                if (enforcedResponse.success === false) {
-                    this.requestTracker.resolveRequest(requestId, enforcedResponse);
-                    return;
-                }
-
-                // If the response indicates it's already saved/done, resolve immediately
-                const result = enforcedResponse.result as ResponseResult | undefined;
-                if (result && result.saved === true) {
-                    this.requestTracker.resolveRequest(requestId, enforcedResponse);
-                    return;
-                }
-
-                // Set event timeout
-                const eventTimeoutMs = pending.eventTimeoutMs || 30000; // Default 30s for event
-                pending.eventTimeout = setTimeout(() => {
-                    this.requestTracker.rejectRequest(requestId, new Error(`Timed out waiting for completion event for ${pending.action}`));
-                }, eventTimeoutMs);
-
-                this.log.debug(`Received initial response for ${pending.action}, waiting for completion event...`);
-            } else {
-                // Second response, treat as completion
-                this.requestTracker.resolveRequest(requestId, enforcedResponse);
-            }
-        } else {
-            this.requestTracker.resolveRequest(requestId, enforcedResponse);
-        }
-    }
-
-    private handleAutomationEvent(message: AutomationBridgeMessage): void {
-        const evt = message as EventMessage;
-        const reqId = typeof evt.requestId === 'string' ? evt.requestId : undefined;
-
-        if (reqId) {
-            const pending = this.requestTracker.getPendingRequest(reqId);
-            if (pending) {
-                try {
-                    const baseSuccess = (pending.initialResponse && typeof pending.initialResponse.success === 'boolean') ? pending.initialResponse.success : undefined;
-                    const evtSuccess = (evt.result && typeof evt.result.success === 'boolean') ? !!evt.result.success : undefined;
-
-                    const synthetic: AutomationBridgeResponseMessage = {
-                        type: 'automation_response',
-                        requestId: reqId,
-                        success: evtSuccess !== undefined ? evtSuccess : baseSuccess,
-                        message: typeof evt.result?.message === 'string' ? evt.result.message : (typeof evt.message === 'string' ? evt.message : FStringSafe(evt.event)),
-                        error: typeof evt.result?.error === 'string' ? evt.result.error : undefined,
-                        result: evt.result ?? evt.payload ?? undefined
-                    };
-
-                    this.log.info(`automation_event resolved pending request ${reqId} (event=${String(evt.event || '')})`);
-                    this.requestTracker.resolveRequest(reqId, synthetic);
-                } catch (e) {
-                    this.log.warn(`Failed to resolve pending automation request from automation_event ${reqId}: ${String(e)}`);
-                }
-                return;
-            }
-        }
-
-        this.log.debug('Received automation_event (no pending request):', message);
-    }
-
-    private enforceActionMatch(response: AutomationBridgeResponseMessage, expectedAction: string): AutomationBridgeResponseMessage {
-        try {
-            const expected = (expectedAction || '').toString().toLowerCase();
-            const echoed: string | undefined = (() => {
-                const r = response as ResponseWithAction;
-                const resultObj = response.result as ResponseResult | undefined;
-                const candidate = (typeof r.action === 'string' && r.action) || (typeof resultObj?.action === 'string' && resultObj.action);
-                return candidate || undefined;
-            })();
-
-            if (expected && echoed && typeof echoed === 'string') {
-                const got = echoed.toLowerCase();
-
-                const consolidatedToolActions = new Set([
-                    'animation_physics',
-                    'create_effect',
-                    'build_environment',
-                    'system_control',
-                    'manage_ui'
-                ]);
-
-                if (consolidatedToolActions.has(expected) && got !== expected) {
-                    return response;
-                }
-
-                const startsEitherWay = got.startsWith(expected) || expected.startsWith(got);
-
-                if (!startsEitherWay) {
-                    const mutated: ResponseWithAction = { ...response };
-                    mutated.success = false;
-                    if (!mutated.error) mutated.error = 'ACTION_PREFIX_MISMATCH';
-                    const msgBase = typeof mutated.message === 'string' ? mutated.message + ' ' : '';
-                    mutated.message = `${msgBase}Response action mismatch (expected~='${expected}', got='${echoed}')`;
-                    return mutated as AutomationBridgeResponseMessage;
-                }
-            }
-        } catch (e) {
-            this.log.debug('enforceActionMatch check skipped', e instanceof Error ? e.message : String(e));
-        }
-        return response;
-    }
-}

package/src/automation/request-tracker.ts

@@ -1,155 +0,0 @@
-import { PendingRequest, AutomationBridgeResponseMessage } from './types.js';
-import { randomUUID, createHash } from 'node:crypto';
-
-// Note: The two-phase event pattern was disabled because C++ handlers send a single response,
-// not request+event. All actions now use simple request-response. The PendingRequest interface
-// retains waitForEvent/eventTimeout fields for potential future use.
-
-export class RequestTracker {
-    private pendingRequests = new Map<string, PendingRequest>();
-    private coalescedRequests = new Map<string, Promise<AutomationBridgeResponseMessage>>();
-    private lastRequestSentAt?: Date;
-
-
-    constructor(
-        private maxPendingRequests: number
-    ) { }
-
-    /**
-     * Get the maximum number of pending requests allowed.
-     * @returns The configured maximum pending requests limit
-     */
-    public getMaxPendingRequests(): number {
-        return this.maxPendingRequests;
-    }
-
-    /**
-     * Get the timestamp of when the last request was sent.
-     * @returns The Date of last request or undefined if no requests sent yet
-     */
-    public getLastRequestSentAt(): Date | undefined {
-        return this.lastRequestSentAt;
-    }
-
-    /**
-     * Update the last request sent timestamp.
-     * Called when a new request is dispatched.
-     */
-    public updateLastRequestSentAt(): void {
-        this.lastRequestSentAt = new Date();
-    }
-
-    /**
-     * Create a new pending request with timeout handling.
-     * @param action - The action name being requested
-     * @param payload - The request payload
-     * @param timeoutMs - Timeout in milliseconds before the request fails
-     * @returns Object containing the requestId and a promise that resolves with the response
-     * @throws Error if max pending requests limit is reached
-     */
-    public createRequest(
-        action: string,
-        payload: Record<string, unknown>,
-        timeoutMs: number
-    ): { requestId: string; promise: Promise<AutomationBridgeResponseMessage> } {
-        if (this.pendingRequests.size >= this.maxPendingRequests) {
-            throw new Error(`Max pending requests limit reached (${this.maxPendingRequests})`);
-        }
-
-        const requestId = randomUUID();
-
-        const promise = new Promise<AutomationBridgeResponseMessage>((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                if (this.pendingRequests.has(requestId)) {
-                    this.pendingRequests.delete(requestId);
-                    reject(new Error(`Request ${requestId} timed out after ${timeoutMs}ms`));
-                }
-            }, timeoutMs);
-
-            this.pendingRequests.set(requestId, {
-                resolve,
-                reject,
-                timeout,
-                action,
-                payload,
-                requestedAt: new Date(),
-                // Note: waitForEvent and eventTimeoutMs are preserved for potential future use
-                // but currently all actions use simple request-response pattern
-                waitForEvent: false,
-                eventTimeoutMs: timeoutMs
-            });
-        });
-
-        return { requestId, promise };
-    }
-
-    public getPendingRequest(requestId: string): PendingRequest | undefined {
-        return this.pendingRequests.get(requestId);
-    }
-
-    public resolveRequest(requestId: string, response: AutomationBridgeResponseMessage): void {
-        const pending = this.pendingRequests.get(requestId);
-        if (pending) {
-            clearTimeout(pending.timeout);
-            if (pending.eventTimeout) clearTimeout(pending.eventTimeout);
-            this.pendingRequests.delete(requestId);
-            pending.resolve(response);
-        }
-    }
-
-    public rejectRequest(requestId: string, error: Error): void {
-        const pending = this.pendingRequests.get(requestId);
-        if (pending) {
-            clearTimeout(pending.timeout);
-            if (pending.eventTimeout) clearTimeout(pending.eventTimeout);
-            this.pendingRequests.delete(requestId);
-            pending.reject(error);
-        }
-    }
-
-    public rejectAll(error: Error): void {
-        for (const [, pending] of this.pendingRequests) {
-            clearTimeout(pending.timeout);
-            if (pending.eventTimeout) clearTimeout(pending.eventTimeout);
-            pending.reject(error);
-        }
-        this.pendingRequests.clear();
-    }
-
-    public getPendingCount(): number {
-        return this.pendingRequests.size;
-    }
-
-    public getPendingDetails(): Array<{ requestId: string; action: string; ageMs: number }> {
-        const now = Date.now();
-        return Array.from(this.pendingRequests.entries()).map(([id, pending]) => ({
-            requestId: id,
-            action: pending.action,
-            ageMs: Math.max(0, now - pending.requestedAt.getTime())
-        }));
-    }
-
-    public getCoalescedRequest(key: string): Promise<AutomationBridgeResponseMessage> | undefined {
-        return this.coalescedRequests.get(key);
-    }
-
-    public setCoalescedRequest(key: string, promise: Promise<AutomationBridgeResponseMessage>): void {
-        this.coalescedRequests.set(key, promise);
-        // Remove from map when settled
-        promise.finally(() => {
-            if (this.coalescedRequests.get(key) === promise) {
-                this.coalescedRequests.delete(key);
-            }
-        });
-    }
-
-    public createCoalesceKey(action: string, payload: Record<string, unknown>): string {
-        // Only coalesce read-only operations
-        const readOnlyActions = ['list', 'get_', 'exists', 'search', 'find'];
-        if (!readOnlyActions.some(a => action.startsWith(a))) return '';
-
-        // Create a stable hash of the payload
-        const stablePayload = JSON.stringify(payload, Object.keys(payload).sort());
-        return `${action}:${createHash('md5').update(stablePayload).digest('hex')}`;
-    }
-}