unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/proxy/native-proxy.js

@@ -1,28 +1,59 @@
 import { request } from 'node:http';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { CapabilityTokenProvider } from '../automation/capability-token-provider.js';
 import { PACKAGE } from '../constants.js';
+import { projectRootFromEnv } from '../utils/config/ini-reader.js';
 import { Logger } from '../utils/logging/logger.js';
 const NATIVE_PROTOCOLS = ['2025-11-25', '2025-06-18', '2025-03-26'];
+const MODERN_VERSION_KEY = 'io.modelcontextprotocol/protocolVersion';
+function modernHeaders(message) {
+    const version = message.params?._meta?.[MODERN_VERSION_KEY];
+    if (typeof version !== 'string')
+        return undefined;
+    const headers = { 'MCP-Protocol-Version': version, 'Mcp-Method': message.method ?? '' };
+    const field = message.method === 'resources/read' ? 'uri'
+        : message.method === 'tools/call' || message.method === 'prompts/get' ? 'name'
+            : message.method?.startsWith('tasks/') ? 'taskId' : undefined;
+    const name = field ? message.params?.[field] : undefined;
+    if (typeof name === 'string' && name) {
+        headers['Mcp-Name'] = /^[!-~](?:[ -~]*[!-~])?$/u.test(name) ? name : `=?base64?${Buffer.from(name, 'utf8').toString('base64')}?=`;
+    }
+    return headers;
+}
 const PLACEHOLDER_TOOL = {
     name: 'unreal',
     description: 'Unreal Engine editor: operation search, describe, execute or configure. The editor has not been '
         + 'reached yet, so this is a placeholder; the full contract replaces it once the editor answers.',
     inputSchema: { type: 'object', properties: { operation: { type: 'string', enum: ['search', 'describe', 'execute', 'configure'] } }, required: ['operation'] }
 };
+export async function readCapabilityToken() {
+    const fromEnv = process.env.MCP_AUTOMATION_CAPABILITY_TOKEN;
+    if (fromEnv)
+        return fromEnv;
+    const projectRoot = projectRootFromEnv();
+    if (!projectRoot)
+        return undefined;
+    try {
+        const token = (await readFile(join(projectRoot, 'Saved', 'MCP', 'capability-token'), 'utf8')).trim().toLowerCase();
+        return /^[0-9a-f]{64}$/u.test(token) ? token : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 export function startNativeProxy(options = {}) {
     const upstream = options.upstream ?? process.env.UNREAL_MCP_URL ?? 'http://127.0.0.1:3000/mcp';
     const cacheFile = options.cacheFile ?? process.env.UNREAL_MCP_PROXY_CACHE
         ?? join(process.env.LOCALAPPDATA ?? process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'unreal-mcp', `proxy-${new URL(upstream).port || '80'}.json`);
     const output = options.output ?? process.stdout;
     const log = new Logger('NativeProxy');
-    const tokenProvider = new CapabilityTokenProvider(undefined, log);
-    const token = options.token ?? (() => tokenProvider.resolve());
+    const token = options.token ?? readCapabilityToken;
     const notConnected = `NOT_CONNECTED: the Unreal Editor is not running (nothing answers at ${upstream}). `
-        + 'Start the editor and call again; this server stays connected, no reconnect is needed.';
+        + 'Start the editor and call again; this server stays connected, no reconnect is needed. If the editor is '
+        + 'running, turn on Project Settings > EngineWire > Enable Native MCP Server and restart it.';
     const proxyNote = 'This server is reached through the unreal-engine-mcp-server proxy: while the editor is not '
         + 'running every call answers NOT_CONNECTED; once the editor is up the next call reaches it, with no reconnect.';
     let cache = {};
@@ -46,13 +77,14 @@ export function startNativeProxy(options = {}) {
             log.warn(`cache not written: ${String(error)}`);
         }
     };
-    const post = async (body, current, onNotification) => {
+    const post = async (body, current, onNotification, modern) => {
         const payload = JSON.stringify(body);
         const headers = {
             'Content-Type': 'application/json',
             Accept: 'application/json, text/event-stream',
             Connection: 'close',
-            'Content-Length': Buffer.byteLength(payload)
+            'Content-Length': Buffer.byteLength(payload),
+            ...modern
         };
         const capabilityToken = await token();
         if (capabilityToken)
@@ -153,6 +185,9 @@ export function startNativeProxy(options = {}) {
         return opening;
     };
     const forward = async (message) => {
+        const modern = modernHeaders(message);
+        if (modern)
+            return post(message, undefined, write, modern);
         for (let attempt = 1;; attempt += 1) {
             const current = await openSession();
             let res;
@@ -186,7 +221,9 @@ export function startNativeProxy(options = {}) {
             'logging/setLevel': {}
         };
         const result = results[message.method ?? ''];
-        return result ? { jsonrpc: '2.0', id: message.id, result } : { jsonrpc: '2.0', id: message.id, error: { code: -32000, message: why } };
+        if (!result)
+            return { jsonrpc: '2.0', id: message.id, error: { code: -32000, message: why } };
+        return { jsonrpc: '2.0', id: message.id, result: modernHeaders(message) ? { resultType: 'complete', ...result } : result };
     };
     const handle = async (message) => {
         const { id, method } = message;
@@ -197,6 +234,8 @@ export function startNativeProxy(options = {}) {
                 clientReady = true;
                 openSession().catch(() => { });
             }
+            else if (modernHeaders(message)) {
+            }
             else if (session) {
                 post(message, session).catch(() => { });
             }
@@ -205,12 +244,14 @@ export function startNativeProxy(options = {}) {
         if (method === 'initialize') {
             const requested = message.params?.protocolVersion;
             clientProtocol = typeof requested === 'string' && NATIVE_PROTOCOLS.includes(requested) ? requested : NATIVE_PROTOCOLS[0];
+            const upstreamCapabilities = cache.capabilities ?? { resources: {}, prompts: {}, completions: {} };
+            const { subscribe: _unrelayed, ...resources } = (upstreamCapabilities.resources ?? {});
             write({
                 jsonrpc: '2.0',
                 id,
                 result: {
                     protocolVersion: clientProtocol,
-                    capabilities: { ...(cache.capabilities ?? { resources: {}, prompts: {}, completions: {} }), tools: { listChanged: true } },
+                    capabilities: { ...upstreamCapabilities, ...('resources' in upstreamCapabilities ? { resources } : {}), tools: { listChanged: true } },
                     serverInfo: { name: `${PACKAGE.name} proxy`, version: PACKAGE.version },
                     instructions: cache.instructions ? `${cache.instructions}\n\n${proxyNote}` : proxyNote
                 }

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "unreal-engine-mcp-server",
-  "version": "0.6.0-beta-e",
+  "version": "0.6.0",
   "mcpName": "io.github.ChiR24/unreal-engine-mcp",
-  "description": "A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal Engine via native automation bridge. Built with TypeScript and designed for game development automation.",
+  "description": "EngineWire: an MCP server and Unreal Editor plugin that let AI assistants build in Unreal Engine 5.0-5.8: levels, Blueprints, UI, materials, effects and more.",
+  "homepage": "https://enginewire.dev",
   "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "bin": {
     "unreal-engine-mcp-server": "dist/cli.js"
   },
   "files": [
-    "dist/**",
-    "!dist/**/*.js.map",
-    "!dist/**/*.d.ts.map",
+    "dist/cli.js",
+    "dist/constants.js",
+    "dist/proxy/*.js",
+    "dist/utils/config/*.js",
+    "dist/utils/logging/*.js",
     "server.json",
     "README.md",
     "LICENSE",
@@ -28,7 +29,7 @@
     "lint:fix": "eslint . --fix",
     "lint:cpp": "echo \"Running C/C++ lint (cpplint)\" && (python -m cpplint --recursive plugins || echo 'cpplint not found; skipping C/C++ lint')",
     "clean": "node -e \"for (const p of ['dist','tsconfig.tsbuildinfo']) require('fs').rmSync(p,{recursive:true,force:true})\"",
-    "prepare": "node -e \"const fs=require('fs');(fs.existsSync('dist')&&fs.existsSync('dist/cli.js')&&fs.existsSync('dist/index.js'))||require('child_process').execSync('npm run build',{stdio:'inherit'})\"",
+    "prepare": "node -e \"require('fs').existsSync('dist/cli.js')||require('child_process').execSync('npm run build',{stdio:'inherit'})\"",
     "automation:sync": "node scripts/sync-mcp-plugin.js",
     "clean:tmp": "node -e \"require('fs').rmSync('tmp',{recursive:true,force:true})\"",
     "test": "node tests/integration.mjs",
@@ -36,7 +37,6 @@
     "test:unit:watch": "vitest",
     "test:unit:coverage": "vitest run --coverage",
     "test:all": "node tests/integration.mjs",
-    "test:smoke": "node --loader ts-node/esm scripts/smoke-test.ts",
     "test:params": "node tests/parameter-combination-audit.mjs --static --strict --optional-strict",
     "type-check": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit",
     "type-check:src": "tsc --noEmit",
@@ -54,6 +54,7 @@
     "node": ">=20.19.0"
   },
   "keywords": [
+    "enginewire",
     "mcp",
     "modelcontextprotocol",
     "unreal",
@@ -65,23 +66,18 @@
   ],
   "author": "Unreal Engine MCP Team",
   "license": "MIT",
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "1.32.1",
-    "ws": "^8.18.3",
-    "zod": "^4.2.1"
-  },
   "devDependencies": {
     "@eslint/js": "9.39.5",
+    "@modelcontextprotocol/client": "2.3.1",
     "@types/node": "^26.0.1",
-    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "8.63.0",
     "@typescript-eslint/parser": "8.63.0",
     "@vitest/coverage-v8": "^4.0.16",
-    "ajv": "^8.20.0",
     "eslint": "9.39.5",
     "eslint-plugin-n": "^18.2.2",
     "ts-node": "^10.9.2",
     "typescript": "5.9.3",
-    "vitest": "^4.0.16"
+    "vitest": "^4.0.16",
+    "zod": "^4.2.1"
   }
 }

package/server.json

@@ -1,82 +1,37 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.ChiR24/unreal-engine-mcp",
-  "description": "Automate the Unreal Editor (UE 5.0-5.8): levels, Blueprints, UI, materials, VFX and more.",
-  "version": "0.6.0-beta-e",
+  "description": "EngineWire: drive the Unreal Editor (UE 5.0-5.8): levels, Blueprints, UI, materials, VFX and more.",
+  "websiteUrl": "https://enginewire.dev",
+  "version": "0.6.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "unreal-engine-mcp-server",
-      "version": "0.6.0-beta-e",
+      "version": "0.6.0",
       "transport": {
         "type": "stdio"
       },
       "environmentVariables": [
         {
           "name": "UE_PROJECT_PATH",
-          "description": "Your Unreal project folder or its .uproject file. The server reads the capability token from <project>/Saved/MCP/capability-token and the WebSocket port from the project settings.",
+          "description": "Your Unreal project folder or its .uproject file. The server reads the capability token from <project>/Saved/MCP/capability-token.",
           "isRequired": true,
           "format": "filepath",
           "placeholder": "C:/Users/YourName/Documents/Unreal Projects/MyGame"
         },
         {
           "name": "MCP_AUTOMATION_CAPABILITY_TOKEN",
-          "description": "Capability token to present to the editor. Only needed when the server cannot read the project folder, for example over LAN.",
+          "description": "Capability token to present to the editor. Only needed when the server cannot read the project folder.",
           "isRequired": false,
           "isSecret": true
         },
         {
-          "name": "MCP_AUTOMATION_PORT",
-          "description": "Editor WebSocket port. Default: the first Listen Ports entry in the project settings, else 8090.",
+          "name": "UNREAL_MCP_URL",
+          "description": "The editor's native MCP endpoint (Project Settings > EngineWire > Native MCP Port).",
           "isRequired": false,
-          "format": "number",
-          "placeholder": "8090"
-        },
-        {
-          "name": "MCP_AUTOMATION_HOST",
-          "description": "Editor host to connect to. A LAN address also needs MCP_AUTOMATION_ALLOW_NON_LOOPBACK=true and Allow Non Loopback in the plugin settings.",
-          "isRequired": false,
-          "default": "127.0.0.1"
-        },
-        {
-          "name": "MCP_AUTOMATION_ALLOW_NON_LOOPBACK",
-          "description": "SECURITY: allow a non-loopback MCP_AUTOMATION_HOST. Enable only on a trusted network.",
-          "isRequired": false,
-          "format": "boolean",
-          "default": "false"
-        },
-        {
-          "name": "MCP_AUTOMATION_USE_TLS",
-          "description": "Connect with wss:// instead of ws://.",
-          "isRequired": false,
-          "format": "boolean",
-          "default": "false"
-        },
-        {
-          "name": "MCP_ADDITIONAL_PATH_PREFIXES",
-          "description": "Extra content roots to allow besides /Game, /Engine, /Script, /Temp and /Niagara, comma-separated. Example: /MyPluginContent/",
-          "isRequired": false
-        },
-        {
-          "name": "MCP_CONNECTION_TIMEOUT_MS",
-          "description": "How long to wait for the editor connection, in milliseconds.",
-          "isRequired": false,
-          "format": "number",
-          "default": "5000"
-        },
-        {
-          "name": "MCP_REQUEST_TIMEOUT_MS",
-          "description": "Overrides every per-capability request timeout, in milliseconds. Leave unset: each capability gets a budget that fits its cost.",
-          "isRequired": false,
-          "format": "number"
-        },
-        {
-          "name": "MCP_AUTOMATION_MAX_MESSAGES_PER_MINUTE",
-          "description": "Inbound messages per minute from the editor before the server disconnects.",
-          "isRequired": false,
-          "format": "number",
-          "default": "600"
+          "default": "http://127.0.0.1:3000/mcp"
         },
         {
           "name": "LOG_LEVEL",
@@ -128,7 +83,7 @@
     "world-partition"
   ],
   "author": "ChiR24",
-  "homepage": "https://github.com/ChiR24/Unreal_mcp",
+  "homepage": "https://enginewire.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/ChiR24/Unreal_mcp.git",

package/dist/automation/bridge-client.d.ts

@@ -1,36 +0,0 @@
-import type { Logger } from '../utils/logging/logger.js';
-import { type AutomationBridgeResolvedConfig } from './bridge-config.js';
-import type { AutomationBridgeRuntimeState } from './bridge-state.js';
-import type { ConnectionManager } from './connection-manager.js';
-import type { HandshakeHandler } from './handshake.js';
-import type { MessageHandler } from './message-handler.js';
-import type { AutomationBridgeEvents, AutomationBridgeMessage } from './types.js';
-interface AutomationBridgeClientDependencies {
-    readonly config: AutomationBridgeResolvedConfig;
-    readonly state: AutomationBridgeRuntimeState;
-    readonly connectionManager: ConnectionManager;
-    readonly handshakeHandler: HandshakeHandler;
-    readonly messageHandler: MessageHandler;
-    readonly log: Logger;
-    readonly emit: <K extends keyof AutomationBridgeEvents>(event: K, ...args: Parameters<AutomationBridgeEvents[K]>) => void;
-    readonly rejectQueuedRequests: (error: Error) => void;
-    readonly rejectPendingRequests: (error: Error) => void;
-}
-export declare class AutomationBridgeClient {
-    private readonly deps;
-    private pendingConnectionSocket?;
-    private readonly abortedConnectionSockets;
-    constructor(deps: AutomationBridgeClientDependencies);
-    getClientUrl(): string;
-    startClient(): void;
-    abortPendingConnection(): void;
-    send(payload: AutomationBridgeMessage): boolean;
-    private handleClientConnection;
-    private recordHandshakeSuccess;
-    private installMessageHandler;
-    private clearPendingConnection;
-    private redactPeerText;
-    private redactPeerError;
-}
-export {};
-//# sourceMappingURL=bridge-client.d.ts.map

package/dist/automation/bridge-client.js

@@ -1,194 +0,0 @@
-import { WebSocket } from 'ws';
-import { MAX_WS_MESSAGE_SIZE_BYTES } from '../constants.js';
-import { redactImagePayloadTextForLog } from '../utils/logging/log-redaction.js';
-import { clearEditorContentRoots, setEditorContentRoots } from '../utils/paths/path-security.js';
-import { formatHostForUrl } from './bridge-config.js';
-import { REDACTED_AUTOMATION_CREDENTIAL, redactAutomationLogRecord, redactKnownAutomationCredentials } from './log-redaction.js';
-import { automationMessageSchema, pluginVersionMismatch, readContentRoots } from './message-schema.js';
-export class AutomationBridgeClient {
-    deps;
-    pendingConnectionSocket;
-    abortedConnectionSockets = new WeakSet();
-    constructor(deps) {
-        this.deps = deps;
-    }
-    getClientUrl() {
-        const scheme = this.deps.config.useTls ? 'wss' : 'ws';
-        return `${scheme}://${formatHostForUrl(this.deps.config.host)}:${this.deps.config.port}`;
-    }
-    startClient() {
-        try {
-            const url = this.getClientUrl();
-            this.deps.log.info(`Connecting to Unreal Engine automation server at ${url}`);
-            this.deps.log.debug(`Negotiated protocols: ${JSON.stringify(this.deps.config.negotiatedProtocols)}`);
-            const protocols = this.deps.config.negotiatedProtocols.length === 1
-                ? this.deps.config.negotiatedProtocols[0]
-                : this.deps.config.negotiatedProtocols;
-            this.deps.log.debug(`Using WebSocket protocols arg: ${JSON.stringify(protocols)}`);
-            const socket = new WebSocket(url, protocols, { perMessageDeflate: false });
-            this.pendingConnectionSocket = socket;
-            this.handleClientConnection(socket);
-        }
-        catch (error) {
-            const errorObj = this.redactPeerError(error);
-            this.deps.state.lastError = { message: errorObj.message, at: new Date() };
-            this.deps.log.error('Failed to create WebSocket client connection', errorObj);
-            this.deps.emit('error', Object.assign(errorObj, { port: this.deps.config.port }));
-        }
-    }
-    abortPendingConnection() {
-        const socket = this.pendingConnectionSocket;
-        this.pendingConnectionSocket = undefined;
-        if (socket && socket.readyState !== WebSocket.CLOSED && socket.readyState !== WebSocket.CLOSING) {
-            this.abortedConnectionSockets.add(socket);
-            try {
-                socket.terminate();
-            }
-            catch (error) {
-                this.deps.log.debug('Failed to terminate timed-out automation bridge socket', error instanceof Error ? error : String(error));
-            }
-        }
-    }
-    send(payload) {
-        const socket = this.deps.connectionManager.getSocket();
-        if (!socket || socket.readyState !== WebSocket.OPEN) {
-            this.deps.log.warn('Attempted to send automation message without an open connection');
-            return false;
-        }
-        try {
-            socket.send(JSON.stringify(payload));
-            return true;
-        }
-        catch (error) {
-            this.deps.log.error('Failed to send automation message', error);
-            const errorObj = error instanceof Error ? error : new Error(String(error));
-            this.deps.emit('error', Object.assign(errorObj, { port: this.deps.connectionManager.getSocketInfo()?.port }));
-            return false;
-        }
-    }
-    async handleClientConnection(socket) {
-        socket.on('open', async () => {
-            this.deps.log.info('Automation bridge client connected, starting handshake');
-            try {
-                await this.deps.handshakeHandler.initiateHandshake(socket, this.deps.config.connectionTimeoutMs, (metadata) => {
-                    this.clearPendingConnection(socket);
-                    this.recordHandshakeSuccess(socket, metadata);
-                    this.installMessageHandler(socket);
-                });
-            }
-            catch (error) {
-                this.clearPendingConnection(socket);
-                const err = this.redactPeerError(error);
-                this.deps.state.lastHandshakeFailure = { reason: err.message, at: new Date() };
-                this.deps.emit('handshakeFailed', { reason: err.message, port: this.deps.config.port });
-            }
-        });
-        socket.on('error', (error) => {
-            this.clearPendingConnection(socket);
-            if (this.abortedConnectionSockets.has(socket)) {
-                this.deps.log.debug('Ignoring error from aborted automation bridge socket', error);
-                return;
-            }
-            const errorObj = this.redactPeerError(error);
-            this.deps.log.error('Automation bridge client socket error', errorObj);
-            this.deps.state.lastError = { message: errorObj.message, at: new Date() };
-            this.deps.emit('error', Object.assign(errorObj, { port: this.deps.config.port }));
-        });
-        socket.on('close', (code, reasonBuffer) => {
-            this.clearPendingConnection(socket);
-            this.abortedConnectionSockets.delete(socket);
-            const reason = this.redactPeerText(reasonBuffer.toString('utf8'));
-            const socketInfo = this.deps.connectionManager.removeSocket(socket);
-            if (!this.deps.connectionManager.getSocket()) {
-                clearEditorContentRoots();
-            }
-            if (!socketInfo) {
-                return;
-            }
-            this.deps.state.lastDisconnect = { code, reason, at: new Date() };
-            this.deps.emit('disconnected', {
-                code,
-                reason,
-                port: socketInfo.port,
-                protocol: socketInfo.protocol || null
-            });
-            this.deps.log.info(`Automation bridge client socket closed (code=${code}, reason=${reason})`);
-            const error = new Error(reason || 'Connection lost');
-            this.deps.rejectQueuedRequests(error);
-            this.deps.rejectPendingRequests(error);
-        });
-    }
-    recordHandshakeSuccess(socket, metadata) {
-        this.deps.state.lastHandshakeAt = new Date();
-        this.deps.state.lastHandshakeMetadata = metadata;
-        setEditorContentRoots(readContentRoots(metadata));
-        const versionMismatch = pluginVersionMismatch(metadata);
-        if (versionMismatch !== undefined)
-            this.deps.log.warn(versionMismatch);
-        this.deps.state.lastHandshakeFailure = undefined;
-        this.deps.connectionManager.updateLastMessageTime();
-        const socketWithInternal = socket;
-        const underlying = socketWithInternal._socket || socketWithInternal.socket;
-        this.deps.connectionManager.registerSocket(socket, this.deps.config.port, metadata, underlying?.remoteAddress ?? undefined, underlying?.remotePort ?? undefined);
-        this.deps.connectionManager.startHeartbeat();
-        this.deps.emit('connected', {
-            socket,
-            metadata: redactAutomationLogRecord(metadata),
-            port: this.deps.config.port,
-            protocol: socket.protocol || null
-        });
-    }
-    installMessageHandler(socket) {
-        socket.on('message', (data) => {
-            try {
-                const frame = data;
-                if (frame.length > MAX_WS_MESSAGE_SIZE_BYTES) {
-                    this.deps.log.error(`Received oversized message (${frame.length} bytes, max: ${MAX_WS_MESSAGE_SIZE_BYTES}). Dropping.`);
-                    return;
-                }
-                if (!this.deps.connectionManager.recordInboundMessage(socket)) {
-                    this.deps.log.warn('Inbound message rate limit exceeded; closing connection.');
-                    socket.close(4008, 'Rate limit exceeded');
-                    return;
-                }
-                const text = frame.toString('utf8');
-                if (this.deps.log.isEnabled('debug')) {
-                    this.deps.log.debug(`[AutomationBridge Client] Received message: ${redactImagePayloadTextForLog(text).substring(0, 1000)}`);
-                }
-                const parsed = JSON.parse(text);
-                const validation = automationMessageSchema.safeParse(parsed);
-                if (!validation.success) {
-                    this.deps.log.warn('Dropped invalid automation message', validation.error.issues);
-                    return;
-                }
-                this.deps.connectionManager.updateLastMessageTime();
-                this.deps.messageHandler.handleMessage(validation.data);
-                this.deps.emit('message', validation.data);
-            }
-            catch (error) {
-                this.deps.log.error('Error handling message', error instanceof Error ? error : String(error));
-            }
-        });
-    }
-    clearPendingConnection(socket) {
-        if (this.pendingConnectionSocket === socket) {
-            this.pendingConnectionSocket = undefined;
-        }
-    }
-    redactPeerText(value) {
-        const knownCredentials = this.deps.config.capabilityToken
-            ? [this.deps.config.capabilityToken]
-            : [];
-        const redacted = redactKnownAutomationCredentials(value, knownCredentials);
-        return typeof redacted === 'string'
-            ? redacted
-            : REDACTED_AUTOMATION_CREDENTIAL;
-    }
-    redactPeerError(value) {
-        const source = value instanceof Error ? value : new Error(String(value));
-        const redacted = new Error(this.redactPeerText(source.message));
-        redacted.name = source.name;
-        return redacted;
-    }
-}
-//# sourceMappingURL=bridge-client.js.map

package/dist/automation/bridge-config.d.ts

@@ -1,25 +0,0 @@
-import type { Logger } from '../utils/logging/logger.js';
-import type { AutomationBridgeOptions } from './types.js';
-type BridgeConfigLogger = Pick<Logger, 'debug' | 'warn' | 'error'>;
-export interface AutomationBridgeResolvedConfig {
-    readonly host: string;
-    readonly port: number;
-    readonly negotiatedProtocols: string[];
-    readonly capabilityToken?: string;
-    readonly enabled: boolean;
-    readonly serverName: string;
-    readonly serverVersion: string;
-    readonly maxQueuedRequests: number;
-    readonly maxPendingRequests: number;
-    readonly useTls: boolean;
-    readonly connectionTimeoutMs: number;
-    readonly heartbeatIntervalMs: number;
-    readonly maxInboundMessagesPerMinute: number;
-}
-export type BridgeFailureReason = 'connection refused' | 'timed out' | 'host unreachable' | 'tls failure' | 'handshake rejected' | 'connection lost' | 'server stopped' | 'bridge disabled' | 'unknown failure';
-export declare function describeBridgeFailure(cause: unknown): BridgeFailureReason;
-export declare function bridgeNotConnectedMessage(target?: string, reason?: BridgeFailureReason): string;
-export declare function formatHostForUrl(host: string): string;
-export declare function resolveAutomationBridgeConfig(options: AutomationBridgeOptions, log: BridgeConfigLogger): AutomationBridgeResolvedConfig;
-export {};
-//# sourceMappingURL=bridge-config.d.ts.map