unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/automation/bridge.js

@@ -1,213 +1,67 @@
 import { EventEmitter } from 'node:events';
-import net from 'node:net';
-import { WebSocket } from 'ws';
-import { Logger } from '../utils/logger.js';
-import { DEFAULT_AUTOMATION_HOST, DEFAULT_AUTOMATION_PORT, DEFAULT_NEGOTIATED_PROTOCOLS, DEFAULT_HEARTBEAT_INTERVAL_MS, DEFAULT_MAX_PENDING_REQUESTS, DEFAULT_MAX_QUEUED_REQUESTS, DEFAULT_MAX_INBOUND_MESSAGES_PER_MINUTE, DEFAULT_MAX_INBOUND_AUTOMATION_REQUESTS_PER_MINUTE, MAX_WS_MESSAGE_SIZE_BYTES } from '../constants.js';
-import { createRequire } from 'node:module';
+import { AutomationBridgeClient } from './bridge-client.js';
+import { resolveAutomationBridgeConfig } from './bridge-config.js';
+import { AutomationRequestDispatcher } from './bridge-request-dispatcher.js';
+import { buildAutomationBridgeStatus } from './bridge-status.js';
+import { CapabilityTokenProvider } from './capability-token-provider.js';
 import { ConnectionManager } from './connection-manager.js';
-import { RequestTracker } from './request-tracker.js';
 import { HandshakeHandler } from './handshake.js';
+import { AutomationLogger } from './log-redaction.js';
+import { readBridgeAuthority } from './message-schema.js';
 import { MessageHandler } from './message-handler.js';
-import { automationMessageSchema } from './message-schema.js';
-import { config } from '../config.js';
-const require = createRequire(import.meta.url);
-const packageInfo = (() => {
-    try {
-        return require('../../package.json');
-    }
-    catch (error) {
-        const log = new Logger('AutomationBridge');
-        log.debug('Unable to read package.json for version info', error);
-        return {};
-    }
-})();
+import { RequestTracker } from './request-tracker.js';
 export class AutomationBridge extends EventEmitter {
-    host;
-    port;
-    ports;
-    negotiatedProtocols;
-    capabilityToken;
-    enabled;
-    serverName;
-    serverVersion;
-    clientHost;
-    clientPort;
-    serverLegacyEnabled;
-    maxConcurrentConnections;
-    maxQueuedRequests;
-    useTls;
+    config;
+    state = {};
     connectionManager;
     requestTracker;
+    capabilityTokenProvider;
     handshakeHandler;
     messageHandler;
-    log = new Logger('AutomationBridge');
-    lastHandshakeAt;
-    lastHandshakeMetadata;
-    lastHandshakeAck;
-    lastHandshakeFailure;
-    lastDisconnect;
-    lastError;
-    queuedRequestItems = [];
-    connectionPromise;
-    connectionLock = false;
+    client;
+    requestDispatcher;
+    log = new AutomationLogger('AutomationBridge');
+    progressListener;
+    cancelledListener;
     constructor(options = {}) {
         super();
-        const allowNonLoopback = options.allowNonLoopback
-            ?? (process.env.MCP_AUTOMATION_ALLOW_NON_LOOPBACK?.toLowerCase() === 'true');
-        const normalizeHost = (value, label) => {
-            const stringValue = typeof value === 'string'
-                ? value
-                : value === undefined || value === null
-                    ? ''
-                    : String(value);
-            const trimmed = stringValue.trim();
-            if (trimmed.length === 0) {
-                return DEFAULT_AUTOMATION_HOST;
-            }
-            const lower = trimmed.toLowerCase();
-            if (lower === 'localhost' || lower === '127.0.0.1') {
-                return '127.0.0.1';
-            }
-            if (lower === '::1' || lower === '[::1]') {
-                return '::1';
-            }
-            if (allowNonLoopback) {
-                let addressToValidate = trimmed;
-                if (addressToValidate.startsWith('[') && addressToValidate.endsWith(']')) {
-                    addressToValidate = addressToValidate.slice(1, -1);
-                }
-                const zoneIndex = addressToValidate.indexOf('%');
-                const addressWithoutZone = zoneIndex >= 0
-                    ? addressToValidate.slice(0, zoneIndex)
-                    : addressToValidate;
-                const ipVersion = net.isIP(addressWithoutZone);
-                if (ipVersion === 4 || ipVersion === 6) {
-                    this.log.warn(`SECURITY: ${label} set to non-loopback address '${trimmed}'. ` +
-                        'The automation bridge will be accessible from your local network.');
-                    return addressToValidate;
-                }
-                const hasLetters = /[a-zA-Z]/.test(trimmed);
-                if (hasLetters) {
-                    const labels = trimmed.split('.');
-                    const isValidHostname = labels.every((label) => label.length > 0 && /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label));
-                    if (isValidHostname) {
-                        this.log.warn(`SECURITY: ${label} set to hostname '${trimmed}'. ` +
-                            'The automation bridge will be accessible from your local network.');
-                        return trimmed;
-                    }
-                }
-                this.log.error(`${label} '${trimmed}' is not a valid IPv4/IPv6 address or hostname. ` +
-                    `Falling back to ${DEFAULT_AUTOMATION_HOST}.`);
-                return DEFAULT_AUTOMATION_HOST;
-            }
-            this.log.warn(`${label} '${trimmed}' is not a loopback address and MCP_AUTOMATION_ALLOW_NON_LOOPBACK is not set. ` +
-                `Falling back to ${DEFAULT_AUTOMATION_HOST}. Set MCP_AUTOMATION_ALLOW_NON_LOOPBACK=true for LAN access.`);
-            return DEFAULT_AUTOMATION_HOST;
-        };
-        const rawHost = options.host
-            ?? process.env.MCP_AUTOMATION_WS_HOST
-            ?? process.env.MCP_AUTOMATION_HOST
-            ?? DEFAULT_AUTOMATION_HOST;
-        this.host = normalizeHost(rawHost, 'Automation bridge host');
-        const sanitizePort = (value) => {
-            if (typeof value === 'number' && Number.isInteger(value)) {
-                return value > 0 && value <= 65535 ? value : null;
-            }
-            if (typeof value === 'string' && value.trim().length > 0) {
-                const parsed = Number.parseInt(value.trim(), 10);
-                return Number.isInteger(parsed) && parsed > 0 && parsed <= 65535 ? parsed : null;
-            }
-            return null;
-        };
-        const defaultPort = sanitizePort(options.port ?? process.env.MCP_AUTOMATION_WS_PORT) ?? DEFAULT_AUTOMATION_PORT;
-        const configuredPortValues = options.ports
-            ? options.ports
-            : process.env.MCP_AUTOMATION_WS_PORTS
-                ?.split(',')
-                .map((token) => token.trim())
-                .filter((token) => token.length > 0);
-        const sanitizedPorts = Array.isArray(configuredPortValues)
-            ? configuredPortValues
-                .map((value) => sanitizePort(value))
-                .filter((port) => port !== null)
-            : [];
-        if (!sanitizedPorts.includes(defaultPort)) {
-            sanitizedPorts.unshift(defaultPort);
-        }
-        if (sanitizedPorts.length === 0) {
-            sanitizedPorts.push(DEFAULT_AUTOMATION_PORT);
-        }
-        this.ports = Array.from(new Set(sanitizedPorts));
-        const defaultProtocols = DEFAULT_NEGOTIATED_PROTOCOLS;
-        const userProtocols = Array.isArray(options.protocols)
-            ? options.protocols.filter((proto) => typeof proto === 'string' && proto.trim().length > 0)
-            : [];
-        const envProtocols = process.env.MCP_AUTOMATION_WS_PROTOCOLS
-            ? process.env.MCP_AUTOMATION_WS_PROTOCOLS.split(',')
-                .map((token) => token.trim())
-                .filter((token) => token.length > 0)
-            : [];
-        this.negotiatedProtocols = Array.from(new Set([...userProtocols, ...envProtocols, ...defaultProtocols]));
-        this.port = this.ports[0];
-        this.serverLegacyEnabled =
-            options.serverLegacyEnabled ?? process.env.MCP_AUTOMATION_SERVER_LEGACY !== 'false';
-        this.capabilityToken =
-            options.capabilityToken ?? process.env.MCP_AUTOMATION_CAPABILITY_TOKEN ?? undefined;
-        this.enabled = options.enabled ?? process.env.MCP_AUTOMATION_BRIDGE_ENABLED !== 'false';
-        this.serverName = options.serverName
-            ?? process.env.MCP_SERVER_NAME
-            ?? packageInfo.name
-            ?? 'unreal-engine-mcp';
-        this.serverVersion = options.serverVersion
-            ?? process.env.MCP_SERVER_VERSION
-            ?? packageInfo.version
-            ?? process.env.npm_package_version
-            ?? '0.0.0';
-        const heartbeatIntervalMs = (options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS) > 0
-            ? (options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS)
-            : 0;
-        const parseNonNegativeInt = (value, fallback) => {
-            if (typeof value === 'number' && Number.isInteger(value)) {
-                return value >= 0 ? value : fallback;
-            }
-            if (typeof value === 'string' && value.trim().length > 0) {
-                const parsed = Number.parseInt(value.trim(), 10);
-                return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
-            }
-            return fallback;
-        };
-        const parseBoolean = (value, defaultValue) => {
-            if (typeof value === 'boolean') {
-                return value;
-            }
-            if (typeof value === 'string') {
-                const normalized = value.trim().toLowerCase();
-                if (normalized === 'true')
-                    return true;
-                if (normalized === 'false')
-                    return false;
+        this.config = resolveAutomationBridgeConfig(options, this.log);
+        this.connectionManager = new ConnectionManager(this.config.heartbeatIntervalMs, this.config.maxInboundMessagesPerMinute, this.config.maxInboundAutomationRequestsPerMinute);
+        this.requestTracker = new RequestTracker(this.config.maxPendingRequests);
+        this.capabilityTokenProvider = new CapabilityTokenProvider(this.config.capabilityToken, this.log);
+        this.handshakeHandler = new HandshakeHandler(this.config.capabilityToken, () => this.capabilityTokenProvider.resolve());
+        this.messageHandler = new MessageHandler(this.requestTracker, (event) => this.emitAutomation('automationEvent', event), (autoId, update) => this.forwardAutomationProgress(autoId, update));
+        this.client = new AutomationBridgeClient({
+            config: this.config,
+            state: this.state,
+            connectionManager: this.connectionManager,
+            handshakeHandler: this.handshakeHandler,
+            messageHandler: this.messageHandler,
+            log: this.log,
+            emit: (event, ...args) => this.emitAutomation(event, ...args),
+            rejectQueuedRequests: (error) => this.requestDispatcher.rejectQueuedRequests(error),
+            rejectPendingRequests: (error) => this.requestDispatcher.rejectPendingRequests(error),
+            rejectOwnedRequests: (ownerId, error) => this.requestDispatcher.rejectOwnedRequests(ownerId, error)
+        });
+        this.requestDispatcher = new AutomationRequestDispatcher({
+            enabled: this.config.enabled,
+            maxQueuedRequests: this.config.maxQueuedRequests,
+            connectionTimeoutMs: this.config.connectionTimeoutMs,
+            requestTracker: this.requestTracker,
+            log: this.log,
+            isConnected: () => this.isConnected(),
+            send: (payload) => this.client.send(payload),
+            getSendOwnerId: () => this.connectionManager.getPrimaryConnectionId(),
+            startClient: () => this.client.startClient(),
+            abortPendingConnection: () => this.client.abortPendingConnection(),
+            describeTarget: () => this.getClientUrl(),
+            once: (event, listener) => {
+                this.once(event, listener);
+            },
+            off: (event, listener) => {
+                this.off(event, listener);
             }
-            return defaultValue;
-        };
-        const maxPendingRequests = Math.max(1, options.maxPendingRequests ?? DEFAULT_MAX_PENDING_REQUESTS);
-        const maxConcurrentConnections = Math.max(1, options.maxConcurrentConnections ?? 10);
-        this.maxQueuedRequests = Math.max(0, options.maxQueuedRequests ?? DEFAULT_MAX_QUEUED_REQUESTS);
-        this.useTls = parseBoolean(options.useTls ?? process.env.MCP_AUTOMATION_USE_TLS, false);
-        const maxInboundMessagesPerMinute = parseNonNegativeInt(options.maxInboundMessagesPerMinute
-            ?? process.env.MCP_AUTOMATION_MAX_MESSAGES_PER_MINUTE, DEFAULT_MAX_INBOUND_MESSAGES_PER_MINUTE);
-        const maxInboundAutomationRequestsPerMinute = parseNonNegativeInt(options.maxInboundAutomationRequestsPerMinute
-            ?? process.env.MCP_AUTOMATION_MAX_AUTOMATION_REQUESTS_PER_MINUTE, DEFAULT_MAX_INBOUND_AUTOMATION_REQUESTS_PER_MINUTE);
-        const rawClientHost = options.clientHost
-            ?? process.env.MCP_AUTOMATION_CLIENT_HOST
-            ?? process.env.MCP_AUTOMATION_HOST
-            ?? DEFAULT_AUTOMATION_HOST;
-        this.clientHost = normalizeHost(rawClientHost, 'Automation bridge client host');
-        this.clientPort = options.clientPort ?? sanitizePort(process.env.MCP_AUTOMATION_CLIENT_PORT) ?? DEFAULT_AUTOMATION_PORT;
-        this.maxConcurrentConnections = maxConcurrentConnections;
-        this.connectionManager = new ConnectionManager(heartbeatIntervalMs, maxInboundMessagesPerMinute, maxInboundAutomationRequestsPerMinute);
-        this.requestTracker = new RequestTracker(maxPendingRequests);
-        this.handshakeHandler = new HandshakeHandler(this.capabilityToken);
-        this.messageHandler = new MessageHandler(this.requestTracker);
+        });
     }
     on(event, listener) {
         return super.on(event, listener);
@@ -219,406 +73,73 @@ export class AutomationBridge extends EventEmitter {
         return super.off(event, listener);
     }
     start() {
-        if (!this.enabled) {
+        if (!this.config.enabled) {
             this.log.info('Automation bridge disabled by configuration.');
             return;
         }
-        const url = this.getClientUrl();
-        this.log.info(`Automation bridge connecting to Unreal server at ${url}`);
-        this.startClient();
+        this.log.info(`Automation bridge connecting to Unreal server at ${this.getClientUrl()}`);
+        this.client.startClient();
     }
-    startClient() {
-        try {
-            const url = this.getClientUrl();
-            this.log.info(`Connecting to Unreal Engine automation server at ${url}`);
-            this.log.debug(`Negotiated protocols: ${JSON.stringify(this.negotiatedProtocols)}`);
-            const protocols = this.negotiatedProtocols.length === 1
-                ? this.negotiatedProtocols[0]
-                : this.negotiatedProtocols;
-            this.log.debug(`Using WebSocket protocols arg: ${JSON.stringify(protocols)}`);
-            const headers = this.capabilityToken
-                ? {
-                    'X-MCP-Capability': this.capabilityToken,
-                    'X-MCP-Capability-Token': this.capabilityToken
-                }
-                : undefined;
-            const socket = new WebSocket(url, protocols, {
-                headers,
-                perMessageDeflate: false
-            });
-            this.handleClientConnection(socket);
-        }
-        catch (error) {
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            this.lastError = { message: errorObj.message, at: new Date() };
-            this.log.error('Failed to create WebSocket client connection', errorObj);
-            const errorWithPort = Object.assign(errorObj, { port: this.clientPort });
-            this.emitAutomation('error', errorWithPort);
-        }
+    setRequestProgressListener(listener) {
+        this.progressListener = listener;
     }
-    async handleClientConnection(socket) {
-        socket.on('open', async () => {
-            this.log.info('Automation bridge client connected, starting handshake');
-            try {
-                const metadata = await this.handshakeHandler.initiateHandshake(socket);
-                this.lastHandshakeAt = new Date();
-                this.lastHandshakeMetadata = metadata;
-                this.lastHandshakeFailure = undefined;
-                this.connectionManager.updateLastMessageTime();
-                const socketWithInternal = socket;
-                const underlying = socketWithInternal._socket || socketWithInternal.socket;
-                const remoteAddr = underlying?.remoteAddress ?? undefined;
-                const remotePort = underlying?.remotePort ?? undefined;
-                this.connectionManager.registerSocket(socket, this.clientPort, metadata, remoteAddr, remotePort);
-                this.connectionManager.startHeartbeat();
-                this.emitAutomation('connected', {
-                    socket,
-                    metadata,
-                    port: this.clientPort,
-                    protocol: socket.protocol || null
-                });
-                const getRawDataByteLength = (data) => {
-                    if (typeof data === 'string') {
-                        return Buffer.byteLength(data, 'utf8');
-                    }
-                    if (Buffer.isBuffer(data)) {
-                        return data.length;
-                    }
-                    if (Array.isArray(data)) {
-                        return data.reduce((total, item) => total + (Buffer.isBuffer(item) ? item.length : 0), 0);
-                    }
-                    if (data instanceof ArrayBuffer) {
-                        return data.byteLength;
-                    }
-                    if (ArrayBuffer.isView(data)) {
-                        return data.byteLength;
-                    }
-                    return 0;
-                };
-                const rawDataToUtf8String = (data, byteLengthHint) => {
-                    if (typeof data === 'string') {
-                        return data;
-                    }
-                    if (Buffer.isBuffer(data)) {
-                        return data.toString('utf8');
-                    }
-                    if (Array.isArray(data)) {
-                        const buffers = data.filter((item) => Buffer.isBuffer(item));
-                        const totalLength = typeof byteLengthHint === 'number'
-                            ? byteLengthHint
-                            : buffers.reduce((total, item) => total + item.length, 0);
-                        return Buffer.concat(buffers, totalLength).toString('utf8');
-                    }
-                    if (data instanceof ArrayBuffer) {
-                        return Buffer.from(data).toString('utf8');
-                    }
-                    if (ArrayBuffer.isView(data)) {
-                        return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString('utf8');
-                    }
-                    return '';
-                };
-                socket.on('message', (data) => {
-                    try {
-                        const byteLength = getRawDataByteLength(data);
-                        if (byteLength > MAX_WS_MESSAGE_SIZE_BYTES) {
-                            this.log.error(`Received oversized message (${byteLength} bytes, max: ${MAX_WS_MESSAGE_SIZE_BYTES}). Dropping.`);
-                            return;
-                        }
-                        const text = rawDataToUtf8String(data, byteLength);
-                        this.log.debug(`[AutomationBridge Client] Received message: ${text.substring(0, 1000)}`);
-                        const parsed = JSON.parse(text);
-                        if (!this.connectionManager.recordInboundMessage(socket, false)) {
-                            this.log.warn('Inbound message rate limit exceeded; closing connection.');
-                            socket.close(4008, 'Rate limit exceeded');
-                            return;
-                        }
-                        const validation = automationMessageSchema.safeParse(parsed);
-                        if (!validation.success) {
-                            this.log.warn('Dropped invalid automation message', validation.error.format());
-                            return;
-                        }
-                        this.connectionManager.updateLastMessageTime();
-                        this.messageHandler.handleMessage(validation.data);
-                        this.emitAutomation('message', validation.data);
-                    }
-                    catch (error) {
-                        this.log.error('Error handling message', error);
-                    }
-                });
-            }
-            catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                this.lastHandshakeFailure = { reason: err.message, at: new Date() };
-                this.emitAutomation('handshakeFailed', { reason: err.message, port: this.clientPort });
-            }
-        });
-        socket.on('error', (error) => {
-            this.log.error('Automation bridge client socket error', error);
-            const errObj = error instanceof Error ? error : new Error(String(error));
-            this.lastError = { message: errObj.message, at: new Date() };
-            const errWithPort = Object.assign(errObj, { port: this.clientPort });
-            this.emitAutomation('error', errWithPort);
-        });
-        socket.on('close', (code, reasonBuffer) => {
-            const reason = reasonBuffer.toString('utf8');
-            const socketInfo = this.connectionManager.removeSocket(socket);
-            if (socketInfo) {
-                this.lastDisconnect = { code, reason, at: new Date() };
-                this.emitAutomation('disconnected', {
-                    code,
-                    reason,
-                    port: socketInfo.port,
-                    protocol: socketInfo.protocol || null
-                });
-                this.log.info(`Automation bridge client socket closed (code=${code}, reason=${reason})`);
-                if (!this.connectionManager.isConnected()) {
-                    this.requestTracker.rejectAll(new Error(reason || 'Connection lost'));
-                }
-            }
-        });
+    reportRequestProgress(mcpRequestId, update) {
+        if (!mcpRequestId)
+            return;
+        this.progressListener?.(mcpRequestId, update);
     }
-    formatHostForUrl(host) {
-        if (!host.includes(':')) {
-            return host;
-        }
-        const zoneIndex = host.indexOf('%');
-        const hostWithoutZone = zoneIndex >= 0 ? host.slice(0, zoneIndex) : host;
-        return `[${hostWithoutZone}]`;
+    setRequestCancelledListener(listener) {
+        this.cancelledListener = listener;
     }
-    getClientUrl() {
-        const scheme = this.useTls ? 'wss' : 'ws';
-        return `${scheme}://${this.formatHostForUrl(this.clientHost)}:${this.clientPort}`;
+    forwardAutomationProgress(autoId, update) {
+        for (const mcpRequestId of this.requestDispatcher.mcpRequestIdsForAuto(autoId)) {
+            this.reportRequestProgress(mcpRequestId, update);
+        }
     }
     stop() {
         if (this.isConnected()) {
-            this.broadcast({
+            this.client.broadcast({
                 type: 'bridge_shutdown',
                 timestamp: new Date().toISOString(),
                 reason: 'Server shutting down'
             });
         }
+        const stopError = new Error('Automation bridge server stopped');
+        this.requestDispatcher.stop(stopError);
         this.connectionManager.closeAll(1001, 'Server shutdown');
-        this.lastHandshakeAck = undefined;
-        this.requestTracker.rejectAll(new Error('Automation bridge server stopped'));
+        this.state.lastHandshakeAck = undefined;
     }
     isConnected() {
         return this.connectionManager.isConnected();
     }
     getStatus() {
-        const connectionInfos = Array.from(this.connectionManager.getActiveSockets().entries()).map(([socket, info]) => ({
-            connectionId: info.connectionId,
-            sessionId: info.sessionId ?? null,
-            remoteAddress: info.remoteAddress ?? null,
-            remotePort: info.remotePort ?? null,
-            port: info.port,
-            connectedAt: info.connectedAt.toISOString(),
-            protocol: info.protocol || null,
-            readyState: socket.readyState,
-            isPrimary: socket === this.connectionManager.getPrimarySocket()
-        }));
-        return {
-            enabled: this.enabled,
-            host: this.host,
-            port: this.port,
-            configuredPorts: [...this.ports],
-            listeningPorts: [],
-            connected: this.isConnected(),
-            connectedAt: connectionInfos.length > 0 ? connectionInfos[0].connectedAt : null,
-            activePort: connectionInfos.length > 0 ? connectionInfos[0].port : null,
-            negotiatedProtocol: connectionInfos.length > 0 ? connectionInfos[0].protocol : null,
-            supportedProtocols: [...this.negotiatedProtocols],
-            supportedOpcodes: ['automation_request'],
-            expectedResponseOpcodes: ['automation_response'],
-            capabilityTokenRequired: Boolean(this.capabilityToken),
-            lastHandshakeAt: this.lastHandshakeAt?.toISOString() ?? null,
-            lastHandshakeMetadata: this.lastHandshakeMetadata ?? null,
-            lastHandshakeAck: this.lastHandshakeAck ?? null,
-            lastHandshakeFailure: this.lastHandshakeFailure
-                ? { reason: this.lastHandshakeFailure.reason, at: this.lastHandshakeFailure.at.toISOString() }
-                : null,
-            lastDisconnect: this.lastDisconnect
-                ? { code: this.lastDisconnect.code, reason: this.lastDisconnect.reason, at: this.lastDisconnect.at.toISOString() }
-                : null,
-            lastError: this.lastError
-                ? { message: this.lastError.message, at: this.lastError.at.toISOString() }
-                : null,
-            lastMessageAt: this.connectionManager.getLastMessageTime()?.toISOString() ?? null,
-            lastRequestSentAt: this.requestTracker.getLastRequestSentAt()?.toISOString() ?? null,
-            pendingRequests: this.requestTracker.getPendingCount(),
-            pendingRequestDetails: this.requestTracker.getPendingDetails(),
-            connections: connectionInfos,
-            webSocketListening: false,
-            serverLegacyEnabled: this.serverLegacyEnabled,
-            serverName: this.serverName,
-            serverVersion: this.serverVersion,
-            maxConcurrentConnections: this.maxConcurrentConnections,
-            maxPendingRequests: this.requestTracker.getMaxPendingRequests(),
-            heartbeatIntervalMs: this.connectionManager.getHeartbeatIntervalMs()
-        };
+        return buildAutomationBridgeStatus({
+            config: this.config,
+            state: this.state,
+            connectionManager: this.connectionManager,
+            requestTracker: this.requestTracker,
+            connected: this.isConnected()
+        });
     }
-    async sendAutomationRequest(action, payload = {}, options = {}) {
-        if (!this.isConnected()) {
-            if (this.enabled) {
-                this.log.info('Automation bridge not connected, attempting lazy connection...');
-                if (!this.connectionPromise && !this.connectionLock) {
-                    this.connectionLock = true;
-                    this.connectionPromise = new Promise((resolve, reject) => {
-                        const onConnect = () => {
-                            cleanup();
-                            resolve();
-                        };
-                        const onError = (err) => {
-                            cleanup();
-                            reject(err);
-                        };
-                        const onHandshakeFail = (err) => {
-                            cleanup();
-                            reject(new Error(`Handshake failed: ${String(err.reason)}`));
-                        };
-                        const cleanup = () => {
-                            this.off('connected', onConnect);
-                            this.off('error', onError);
-                            this.off('handshakeFailed', onHandshakeFail);
-                            this.connectionLock = false;
-                            this.connectionPromise = undefined;
-                        };
-                        this.once('connected', onConnect);
-                        this.once('error', onError);
-                        this.once('handshakeFailed', onHandshakeFail);
-                        try {
-                            this.startClient();
-                        }
-                        catch (e) {
-                            onError(e);
-                        }
-                    });
-                }
-                try {
-                    const connectTimeout = 5000;
-                    let timeoutId;
-                    const timeoutPromise = new Promise((_, reject) => {
-                        timeoutId = setTimeout(() => reject(new Error('Lazy connection timeout')), connectTimeout);
-                    });
-                    try {
-                        await Promise.race([this.connectionPromise, timeoutPromise]);
-                    }
-                    finally {
-                        if (timeoutId)
-                            clearTimeout(timeoutId);
-                    }
-                }
-                catch (err) {
-                    this.log.error('Lazy connection failed', err);
-                    const errObj = err;
-                    throw new Error(`Failed to establish connection to Unreal Engine: ${String(errObj?.message ?? err)}`);
-                }
-            }
-            else {
-                throw new Error('Automation bridge disabled');
-            }
-        }
-        if (!this.isConnected()) {
-            throw new Error('Automation bridge not connected');
-        }
-        if (this.requestTracker.getPendingCount() >= this.requestTracker.getMaxPendingRequests()) {
-            if (this.queuedRequestItems.length >= this.maxQueuedRequests) {
-                throw new Error(`Automation bridge request queue is full (max: ${this.maxQueuedRequests}). Please retry later.`);
-            }
-            return new Promise((resolve, reject) => {
-                this.queuedRequestItems.push({
-                    resolve: resolve,
-                    reject: reject,
-                    action,
-                    payload,
-                    options
-                });
-            });
-        }
-        return this.sendRequestInternal(action, payload, options);
+    getClientUrl() {
+        return this.client.getClientUrl();
     }
-    async sendRequestInternal(action, payload, options) {
-        const timeoutMs = options.timeoutMs ?? config.MCP_REQUEST_TIMEOUT_MS;
-        const coalesceKey = this.requestTracker.createCoalesceKey(action, payload);
-        if (coalesceKey) {
-            const existing = this.requestTracker.getCoalescedRequest(coalesceKey);
-            if (existing) {
-                return existing;
-            }
-        }
-        const { requestId, promise } = this.requestTracker.createRequest(action, payload, timeoutMs);
-        if (coalesceKey) {
-            this.requestTracker.setCoalescedRequest(coalesceKey, promise);
-        }
-        const message = {
-            type: 'automation_request',
-            requestId,
-            action,
-            payload
-        };
-        const resultPromise = promise;
-        resultPromise.finally(() => {
-            this.processRequestQueue();
-        }).catch(() => { });
-        if (this.send(message)) {
-            this.requestTracker.updateLastRequestSentAt();
-            return resultPromise;
-        }
-        else {
-            this.requestTracker.rejectRequest(requestId, new Error('Failed to send request'));
-            throw new Error('Failed to send request');
-        }
+    getAuthority() {
+        return readBridgeAuthority(this.state.lastHandshakeMetadata);
     }
-    processRequestQueue() {
-        if (this.queuedRequestItems.length === 0)
-            return;
-        while (this.queuedRequestItems.length > 0 &&
-            this.requestTracker.getPendingCount() < this.requestTracker.getMaxPendingRequests()) {
-            const item = this.queuedRequestItems.shift();
-            if (item) {
-                this.sendRequestInternal(item.action, item.payload, item.options)
-                    .then(item.resolve)
-                    .catch(item.reject);
-            }
-        }
+    async isCapabilityTokenConfigured() {
+        return (await this.capabilityTokenProvider.resolve()) !== undefined;
     }
-    send(payload) {
-        const primarySocket = this.connectionManager.getPrimarySocket();
-        if (!primarySocket || primarySocket.readyState !== WebSocket.OPEN) {
-            this.log.warn('Attempted to send automation message without an active primary connection');
-            return false;
-        }
-        try {
-            primarySocket.send(JSON.stringify(payload));
-            return true;
-        }
-        catch (error) {
-            this.log.error('Failed to send automation message', error);
-            const errObj = error instanceof Error ? error : new Error(String(error));
-            const primaryInfo = this.connectionManager.getActiveSockets().get(primarySocket);
-            const errorWithPort = Object.assign(errObj, { port: primaryInfo?.port });
-            this.emitAutomation('error', errorWithPort);
-            return false;
-        }
+    async sendAutomationRequest(action, payload = {}, options = {}) {
+        return this.requestDispatcher.sendAutomationRequest(action, payload, options);
     }
-    broadcast(payload) {
-        const sockets = this.connectionManager.getActiveSockets();
-        if (sockets.size === 0) {
-            this.log.warn('Attempted to broadcast automation message without any active connections');
-            return false;
-        }
-        let sentCount = 0;
-        for (const [socket] of sockets) {
-            if (socket.readyState === WebSocket.OPEN) {
-                try {
-                    socket.send(JSON.stringify(payload));
-                    sentCount++;
-                }
-                catch (error) {
-                    this.log.error('Failed to broadcast automation message to socket', error);
-                }
-            }
-        }
-        return sentCount > 0;
+    cancelMcpRequest(requestId, reason) {
+        this.requestDispatcher.cancelMcpRequest(requestId, reason);
+        if (requestId)
+            this.cancelledListener?.(requestId);
+    }
+    send(payload) {
+        return this.client.send(payload);
     }
     emitAutomation(event, ...args) {
         this.emit(event, ...args);