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

package/dist/automation/handshake.js

@@ -1,132 +0,0 @@
-import { WebSocket } from 'ws';
-import { AutomationLogger, REDACTED_AUTOMATION_CREDENTIAL, redactKnownAutomationCredentials } from './log-redaction.js';
-import { bridgeAckSchema } from './message-schema.js';
-export class HandshakeHandler {
-    capabilityToken;
-    resolveToken;
-    log = new AutomationLogger('HandshakeHandler');
-    DEFAULT_HANDSHAKE_TIMEOUT_MS = 5000;
-    constructor(capabilityToken, resolveToken) {
-        this.capabilityToken = capabilityToken;
-        this.resolveToken = resolveToken;
-    }
-    async initiateHandshake(socket, timeoutMs = this.DEFAULT_HANDSHAKE_TIMEOUT_MS, onAcknowledged) {
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const timeout = setTimeout(() => {
-                if (!settled) {
-                    this.log.warn('Automation bridge client handshake timed out');
-                    rejectHandshake(new Error('Handshake timeout'), 4002, 'Handshake timeout');
-                }
-            }, timeoutMs);
-            const cleanup = () => {
-                clearTimeout(timeout);
-                socket.off('message', onMessage);
-                socket.off('error', onError);
-                socket.off('close', onClose);
-            };
-            const rejectHandshake = (error, closeCode, closeReason) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (closeCode !== undefined) {
-                    socket.close(closeCode, closeReason);
-                }
-                cleanup();
-                reject(error);
-            };
-            const resolveHandshake = (metadata) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                try {
-                    onAcknowledged?.(metadata);
-                }
-                catch (error) {
-                    reject(error instanceof Error ? error : new Error(String(error)));
-                    return;
-                }
-                resolve(metadata);
-            };
-            const onMessage = (data) => {
-                let parsed;
-                const text = typeof data === 'string' ? data : data.toString('utf8');
-                try {
-                    parsed = JSON.parse(text);
-                }
-                catch (error) {
-                    this.log.error('Received non-JSON automation message during handshake', error instanceof Error ? error : String(error));
-                    rejectHandshake(new Error('Invalid JSON payload'), 4003, 'Invalid JSON payload');
-                    return;
-                }
-                const validation = bridgeAckSchema.safeParse(parsed);
-                if (validation.success) {
-                    const metadata = this.sanitizeHandshakeMetadata(validation.data);
-                    resolveHandshake(metadata);
-                    return;
-                }
-                const typeHint = typeof parsed.type === 'string' ? parsed.type : 'unknown';
-                this.log.warn(`Expected bridge_ack handshake, received ${typeHint}`, validation.error.issues);
-                rejectHandshake(new Error(`Handshake expected bridge_ack, got ${typeHint}`), 4004, 'Handshake expected bridge_ack');
-            };
-            const onError = (error) => {
-                rejectHandshake(error);
-            };
-            const onClose = () => {
-                rejectHandshake(new Error('Socket closed during handshake'));
-            };
-            socket.on('message', onMessage);
-            socket.on('error', onError);
-            socket.on('close', onClose);
-            void (async () => {
-                if (settled || socket.readyState !== WebSocket.OPEN) {
-                    this.log.warn('Socket closed before bridge_hello could be sent');
-                    return;
-                }
-                let capabilityToken;
-                try {
-                    capabilityToken = this.resolveToken
-                        ? await this.resolveToken()
-                        : this.capabilityToken;
-                }
-                catch (error) {
-                    this.log.error('Capability token resolution failed; sending bridge_hello without a token', error instanceof Error ? error.message : String(error));
-                    capabilityToken = this.capabilityToken || undefined;
-                }
-                if (settled || socket.readyState !== WebSocket.OPEN) {
-                    return;
-                }
-                const helloPayload = {
-                    type: 'bridge_hello',
-                    capabilityToken
-                };
-                try {
-                    socket.send(JSON.stringify(helloPayload));
-                }
-                catch (error) {
-                    rejectHandshake(error instanceof Error ? error : new Error(String(error)));
-                }
-            })();
-        });
-    }
-    sanitizeHandshakeMetadata(payload) {
-        const sanitized = { ...payload };
-        delete sanitized.type;
-        const capabilityToken = typeof sanitized.capabilityToken === 'string'
-            ? sanitized.capabilityToken
-            : undefined;
-        if ('capabilityToken' in sanitized) {
-            sanitized.capabilityToken = REDACTED_AUTOMATION_CREDENTIAL;
-        }
-        if (capabilityToken) {
-            for (const [key, value] of Object.entries(sanitized)) {
-                if (key !== 'capabilityToken') {
-                    sanitized[key] = redactKnownAutomationCredentials(value, [capabilityToken]);
-                }
-            }
-        }
-        return sanitized;
-    }
-}
-//# sourceMappingURL=handshake.js.map

package/dist/automation/index.d.ts

@@ -1,6 +0,0 @@
-export { AutomationBridge } from './bridge.js';
-export { McpRequestCancelledError } from './request-cancellation-error.js';
-export { runWithMcpRequestContext, getMcpRequestContext, canonicalizeMcpRequestId } from './request-context.js';
-export type { McpRequestContext } from './request-context.js';
-export type { AutomationBridgeOptions, AutomationBridgeMessage, AutomationBridgeAutomationEvent, AutomationBridgeResponseMessage, CancelRequestMessage, PendingRequestDetail, AutomationBridgeConnectionInfo, AutomationBridgeConnectedEvent, AutomationBridgeDisconnectedEvent, AutomationBridgePortError, ProgressUpdateMessage, AutomationBridgeStatus, PendingRequest, QueuedRequestItem, SocketInfo, AutomationBridgeEvents } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/automation/index.js

@@ -1,4 +0,0 @@
-export { AutomationBridge } from './bridge.js';
-export { McpRequestCancelledError } from './request-cancellation-error.js';
-export { runWithMcpRequestContext, getMcpRequestContext, canonicalizeMcpRequestId } from './request-context.js';
-//# sourceMappingURL=index.js.map

package/dist/automation/log-redaction.d.ts

@@ -1,11 +0,0 @@
-import { Logger } from '../utils/logging/logger.js';
-export declare const REDACTED_AUTOMATION_CREDENTIAL = "[REDACTED]";
-export declare function redactKnownAutomationCredentials(value: unknown, knownCredentials: readonly string[]): unknown;
-export declare function redactAutomationLogRecord(value: Readonly<Record<string, unknown>>): Record<string, unknown>;
-export declare class AutomationLogger extends Logger {
-    debug(...args: unknown[]): void;
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
-}
-//# sourceMappingURL=log-redaction.d.ts.map

package/dist/automation/log-redaction.js

@@ -1,165 +0,0 @@
-import { Logger } from '../utils/logging/logger.js';
-export const REDACTED_AUTOMATION_CREDENTIAL = '[REDACTED]';
-const SENSITIVE_KEY_NAMES = new Set(['sessionid', 'capabilitytoken', 'xmcpcapability', 'xmcpcapabilitytoken']);
-const SENSITIVE_TEXT_PATTERN = /((?:"|')?(?:session[\s_-]*id|capability[\s_-]*token|x-mcp-capability(?:-token)?)(?:"|')?\s*[:=]\s*)(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,}\]]+)/gi;
-const SENSITIVE_TEXT_VALUE_PATTERN = /(?:"|')?(?:session[\s_-]*id|capability[\s_-]*token|x-mcp-capability(?:-token)?)(?:"|')?\s*[:=]\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s,}\]]+))/gi;
-const MAX_REDACTION_DEPTH = 12;
-function isSensitiveKey(key) {
-    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');
-    return SENSITIVE_KEY_NAMES.has(normalized);
-}
-function addSensitiveValue(values, value) {
-    if (typeof value === 'string' && value.length > 0 && value !== REDACTED_AUTOMATION_CREDENTIAL) {
-        values.add(value);
-    }
-}
-function collectSensitiveTextValues(text, values) {
-    for (const match of text.matchAll(SENSITIVE_TEXT_VALUE_PATTERN)) {
-        addSensitiveValue(values, match[1] ?? match[2] ?? match[3]);
-    }
-}
-function collectSensitiveValuesInternal(value, values, seen, depth) {
-    if (typeof value === 'string') {
-        collectSensitiveTextValues(value, values);
-        return;
-    }
-    if (value === null || typeof value !== 'object' || depth >= MAX_REDACTION_DEPTH || seen.has(value)) {
-        return;
-    }
-    seen.add(value);
-    if (value instanceof Error) {
-        collectSensitiveTextValues(value.message, values);
-        if (value.stack) {
-            collectSensitiveTextValues(value.stack, values);
-        }
-        collectSensitiveValuesInternal(value.cause, values, seen, depth + 1);
-        seen.delete(value);
-        return;
-    }
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            collectSensitiveValuesInternal(item, values, seen, depth + 1);
-        }
-        seen.delete(value);
-        return;
-    }
-    for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
-        if (!('value' in descriptor)) {
-            continue;
-        }
-        if (isSensitiveKey(key)) {
-            addSensitiveValue(values, descriptor.value);
-        }
-        collectSensitiveValuesInternal(descriptor.value, values, seen, depth + 1);
-    }
-    seen.delete(value);
-}
-function collectSensitiveValues(values, knownCredentials = []) {
-    const sensitiveValues = new Set();
-    for (const credential of knownCredentials) {
-        addSensitiveValue(sensitiveValues, credential);
-    }
-    for (const value of values) {
-        collectSensitiveValuesInternal(value, sensitiveValues, new WeakSet(), 0);
-    }
-    return [...sensitiveValues].sort((left, right) => right.length - left.length);
-}
-function redactSensitiveText(text, sensitiveValues) {
-    let redacted = text.replace(SENSITIVE_TEXT_PATTERN, (_match, prefix) => `${prefix}"${REDACTED_AUTOMATION_CREDENTIAL}"`);
-    for (const sensitiveValue of sensitiveValues) {
-        if (sensitiveValue.length > 0) {
-            const escaped = sensitiveValue.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-            const caseInsensitivePattern = new RegExp(escaped, 'giu');
-            redacted = redacted.replace(caseInsensitivePattern, REDACTED_AUTOMATION_CREDENTIAL);
-        }
-        redacted = redacted.split(sensitiveValue).join(REDACTED_AUTOMATION_CREDENTIAL);
-    }
-    return redacted;
-}
-function redactObject(value, seen, depth, sensitiveValues, redactSensitiveKeys) {
-    if (seen.has(value)) {
-        return '[Circular]';
-    }
-    if (depth >= MAX_REDACTION_DEPTH) {
-        return '[Object]';
-    }
-    seen.add(value);
-    const redacted = {};
-    const descriptors = Object.getOwnPropertyDescriptors(value);
-    for (const [key, descriptor] of Object.entries(descriptors)) {
-        if (!('value' in descriptor)) {
-            continue;
-        }
-        redacted[key] = redactSensitiveKeys && isSensitiveKey(key)
-            ? REDACTED_AUTOMATION_CREDENTIAL
-            : redactAutomationLogValueInternal(descriptor.value, seen, depth + 1, sensitiveValues, redactSensitiveKeys);
-    }
-    seen.delete(value);
-    return redacted;
-}
-function redactAutomationLogValueInternal(value, seen, depth, sensitiveValues, redactSensitiveKeys) {
-    if (typeof value === 'string') {
-        return redactSensitiveText(value, sensitiveValues);
-    }
-    if (value === null ||
-        typeof value === 'number' ||
-        typeof value === 'boolean' ||
-        typeof value === 'bigint' ||
-        typeof value === 'undefined') {
-        return value;
-    }
-    if (typeof value === 'symbol' || typeof value === 'function') {
-        return String(value);
-    }
-    if (value instanceof Date) {
-        return value.toISOString();
-    }
-    if (Buffer.isBuffer(value)) {
-        return `<binary; ${value.byteLength} bytes>`;
-    }
-    if (value instanceof Error) {
-        return {
-            name: value.name,
-            message: redactSensitiveText(value.message, sensitiveValues),
-            stack: value.stack ? redactSensitiveText(value.stack, sensitiveValues) : undefined,
-            cause: redactAutomationLogValueInternal(value.cause, seen, depth + 1, sensitiveValues, redactSensitiveKeys)
-        };
-    }
-    if (Array.isArray(value)) {
-        return value.map((item) => redactAutomationLogValueInternal(item, seen, depth + 1, sensitiveValues, redactSensitiveKeys));
-    }
-    return redactObject(value, seen, depth, sensitiveValues, redactSensitiveKeys);
-}
-export function redactKnownAutomationCredentials(value, knownCredentials) {
-    const sensitiveValues = collectSensitiveValues([value], knownCredentials);
-    return redactAutomationLogValueInternal(value, new WeakSet(), 0, sensitiveValues, false);
-}
-export function redactAutomationLogRecord(value) {
-    const sensitiveValues = collectSensitiveValues([value]);
-    const redacted = {};
-    for (const [key, child] of Object.entries(value)) {
-        redacted[key] = isSensitiveKey(key)
-            ? REDACTED_AUTOMATION_CREDENTIAL
-            : redactAutomationLogValueInternal(child, new WeakSet(), 1, sensitiveValues, true);
-    }
-    return redacted;
-}
-function redactAutomationLogArguments(args) {
-    const sensitiveValues = collectSensitiveValues(args);
-    return args.map((argument) => redactAutomationLogValueInternal(argument, new WeakSet(), 0, sensitiveValues, true));
-}
-export class AutomationLogger extends Logger {
-    debug(...args) {
-        super.debug(...redactAutomationLogArguments(args));
-    }
-    info(...args) {
-        super.info(...redactAutomationLogArguments(args));
-    }
-    warn(...args) {
-        super.warn(...redactAutomationLogArguments(args));
-    }
-    error(...args) {
-        super.error(...redactAutomationLogArguments(args));
-    }
-}
-//# sourceMappingURL=log-redaction.js.map

package/dist/automation/message-handler.d.ts

@@ -1,15 +0,0 @@
-import type { RequestTracker } from './request-tracker.js';
-import type { AutomationBridgeAutomationEvent, AutomationBridgeMessage, AutomationProgressUpdate } from './types.js';
-export declare class MessageHandler {
-    private requestTracker;
-    private readonly emitAutomationEvent?;
-    private readonly emitRequestProgress?;
-    private log;
-    constructor(requestTracker: RequestTracker, emitAutomationEvent?: ((event: AutomationBridgeAutomationEvent) => void) | undefined, emitRequestProgress?: ((requestId: string, update: AutomationProgressUpdate) => void) | undefined);
-    handleMessage(message: AutomationBridgeMessage): void;
-    private handleAutomationResponse;
-    private handleAutomationEvent;
-    private normalizeAutomationEvent;
-    private handleProgressUpdate;
-}
-//# sourceMappingURL=message-handler.d.ts.map

package/dist/automation/message-handler.js

@@ -1,103 +0,0 @@
-import { AutomationLogger } from './log-redaction.js';
-export class MessageHandler {
-    requestTracker;
-    emitAutomationEvent;
-    emitRequestProgress;
-    log = new AutomationLogger('MessageHandler');
-    constructor(requestTracker, emitAutomationEvent, emitRequestProgress) {
-        this.requestTracker = requestTracker;
-        this.emitAutomationEvent = emitAutomationEvent;
-        this.emitRequestProgress = emitRequestProgress;
-    }
-    handleMessage(message) {
-        switch (message.type) {
-            case 'automation_response':
-                this.handleAutomationResponse(message);
-                break;
-            case 'automation_event':
-                this.handleAutomationEvent(message);
-                break;
-            case 'progress_update':
-                this.handleProgressUpdate(message);
-                break;
-            default:
-                this.log.debug('Received automation bridge message with no handler', message);
-                break;
-        }
-    }
-    handleAutomationResponse(response) {
-        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;
-        }
-        this.requestTracker.resolveRequest(requestId, response);
-    }
-    handleAutomationEvent(message) {
-        const evt = message;
-        const normalized = this.normalizeAutomationEvent(evt);
-        if (!normalized) {
-            this.log.warn('Dropped automation_event without a valid event name');
-            return;
-        }
-        this.emitAutomationEvent?.(normalized);
-        this.log.debug('Received automation_event:', normalized);
-    }
-    normalizeAutomationEvent(evt) {
-        if (typeof evt.event !== 'string' || evt.event.trim().length === 0) {
-            return null;
-        }
-        const normalized = {
-            type: 'automation_event',
-            event: evt.event.trim()
-        };
-        if (typeof evt.requestId === 'string' && evt.requestId.length > 0) {
-            normalized.requestId = evt.requestId;
-        }
-        if (evt.payload !== undefined) {
-            normalized.payload = evt.payload;
-        }
-        if (evt.result !== undefined) {
-            normalized.result = evt.result;
-        }
-        if (typeof evt.message === 'string' && evt.message.length > 0) {
-            normalized.message = evt.message;
-        }
-        return normalized;
-    }
-    handleProgressUpdate(message) {
-        const { requestId, percent, message: statusMsg, stillWorking } = message;
-        if (!requestId) {
-            this.log.debug('Received progress_update without requestId');
-            return;
-        }
-        const pending = this.requestTracker.getPendingRequest(requestId);
-        if (!pending) {
-            this.log.debug(`No pending request for progress_update requestId=${requestId}`);
-            return;
-        }
-        const progressStr = percent !== undefined ? ` (${percent.toFixed(1)}%)` : '';
-        const msgStr = statusMsg ? `: ${statusMsg}` : '';
-        this.log.debug(`Progress update for ${pending.action}${progressStr}${msgStr}`);
-        if (stillWorking === false) {
-            this.log.debug(`Progress update indicates operation completing for ${pending.action}`);
-        }
-        if (percent !== undefined && Number.isFinite(percent)) {
-            this.emitRequestProgress?.(requestId, {
-                progress: percent,
-                total: 100,
-                ...(statusMsg ? { message: statusMsg } : {})
-            });
-        }
-        const extended = this.requestTracker.extendTimeout(requestId, percent);
-        if (!extended) {
-            this.log.warn(`Timeout extension rejected for ${pending.action} - possible deadlock detected`);
-        }
-    }
-}
-//# sourceMappingURL=message-handler.js.map

package/dist/automation/message-schema.d.ts

@@ -1,128 +0,0 @@
-import { z } from 'zod';
-export declare const automationResponseSchema: z.ZodObject<{
-    type: z.ZodLiteral<"automation_response">;
-    requestId: z.ZodString;
-    success: z.ZodOptional<z.ZodBoolean>;
-    message: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    action: z.ZodOptional<z.ZodString>;
-    liveRevisions: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        selection: z.ZodNumber;
-        level: z.ZodNumber;
-        assetRegistry: z.ZodNumber;
-        package: z.ZodNumber;
-        serverInstanceId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-}, z.core.$loose>;
-export declare const automationEventSchema: z.ZodObject<{
-    type: z.ZodLiteral<"automation_event">;
-    requestId: z.ZodOptional<z.ZodString>;
-    event: z.ZodOptional<z.ZodString>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export declare const bridgeAuthoritySchema: z.ZodObject<{
-    profile: z.ZodOptional<z.ZodString>;
-    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    deprecated: z.ZodOptional<z.ZodBoolean>;
-    tokenRequired: z.ZodOptional<z.ZodBoolean>;
-    pathRestricted: z.ZodOptional<z.ZodBoolean>;
-    projectRestricted: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export type BridgeAuthority = z.infer<typeof bridgeAuthoritySchema>;
-export declare function readBridgeAuthority(metadata: Record<string, unknown> | undefined): BridgeAuthority | undefined;
-export declare const bridgeAckSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge_ack">;
-    message: z.ZodOptional<z.ZodString>;
-    serverName: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    protocolVersion: z.ZodOptional<z.ZodNumber>;
-    pluginVersion: z.ZodOptional<z.ZodString>;
-    authority: z.ZodOptional<z.ZodObject<{
-        profile: z.ZodOptional<z.ZodString>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        deprecated: z.ZodOptional<z.ZodBoolean>;
-        tokenRequired: z.ZodOptional<z.ZodBoolean>;
-        pathRestricted: z.ZodOptional<z.ZodBoolean>;
-        projectRestricted: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    contentRoots: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$loose>;
-export declare const CONTENT_ROOTS_CHANGED_EVENT = "content_roots_changed";
-export declare function readContentRoots(source: unknown): unknown;
-export declare function pluginVersionMismatch(metadata: Record<string, unknown> | undefined): string | undefined;
-export declare const bridgeErrorSchema: z.ZodObject<{
-    type: z.ZodLiteral<"bridge_error">;
-    error: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export declare const progressUpdateSchema: z.ZodObject<{
-    type: z.ZodLiteral<"progress_update">;
-    requestId: z.ZodString;
-    percent: z.ZodOptional<z.ZodNumber>;
-    message: z.ZodOptional<z.ZodString>;
-    timestamp: z.ZodOptional<z.ZodString>;
-    stillWorking: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$loose>;
-export declare const cancelRequestSchema: z.ZodObject<{
-    type: z.ZodLiteral<"cancel_request">;
-    requestId: z.ZodString;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>;
-export declare const automationMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    type: z.ZodLiteral<"automation_response">;
-    requestId: z.ZodString;
-    success: z.ZodOptional<z.ZodBoolean>;
-    message: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    action: z.ZodOptional<z.ZodString>;
-    liveRevisions: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
-        selection: z.ZodNumber;
-        level: z.ZodNumber;
-        assetRegistry: z.ZodNumber;
-        package: z.ZodNumber;
-        serverInstanceId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-}, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"automation_event">;
-    requestId: z.ZodOptional<z.ZodString>;
-    event: z.ZodOptional<z.ZodString>;
-    payload: z.ZodOptional<z.ZodUnknown>;
-    result: z.ZodOptional<z.ZodUnknown>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"bridge_ack">;
-    message: z.ZodOptional<z.ZodString>;
-    serverName: z.ZodOptional<z.ZodString>;
-    sessionId: z.ZodOptional<z.ZodString>;
-    protocolVersion: z.ZodOptional<z.ZodNumber>;
-    pluginVersion: z.ZodOptional<z.ZodString>;
-    authority: z.ZodOptional<z.ZodObject<{
-        profile: z.ZodOptional<z.ZodString>;
-        scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        deprecated: z.ZodOptional<z.ZodBoolean>;
-        tokenRequired: z.ZodOptional<z.ZodBoolean>;
-        pathRestricted: z.ZodOptional<z.ZodBoolean>;
-        projectRestricted: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    contentRoots: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"bridge_error">;
-    error: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"progress_update">;
-    requestId: z.ZodString;
-    percent: z.ZodOptional<z.ZodNumber>;
-    message: z.ZodOptional<z.ZodString>;
-    timestamp: z.ZodOptional<z.ZodString>;
-    stillWorking: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$loose>, z.ZodObject<{
-    type: z.ZodLiteral<"cancel_request">;
-    requestId: z.ZodString;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$loose>], "type">;
-//# sourceMappingURL=message-schema.d.ts.map

package/dist/automation/message-schema.js

@@ -1,92 +0,0 @@
-import { z } from 'zod';
-import { PACKAGE } from '../constants.js';
-import { LiveStateRevisionsSchema } from '../tools/catalog/capabilities/semantic/live-state-revisions.js';
-const RELEASE_TAG_URL = 'https://github.com/ChiR24/Unreal_mcp/releases/tag/v';
-const stringArray = z.array(z.string());
-const nonNegativeInteger = z.number().int().min(0);
-export const automationResponseSchema = z.looseObject({
-    type: z.literal('automation_response'),
-    requestId: z.string().min(1),
-    success: z.boolean().optional(),
-    message: z.string().optional(),
-    error: z.string().optional(),
-    result: z.unknown().optional(),
-    action: z.string().optional(),
-    liveRevisions: LiveStateRevisionsSchema.optional()
-});
-export const automationEventSchema = z.looseObject({
-    type: z.literal('automation_event'),
-    requestId: z.string().optional(),
-    event: z.string().optional(),
-    payload: z.unknown().optional(),
-    result: z.unknown().optional(),
-    message: z.string().optional()
-});
-export const bridgeAuthoritySchema = z.object({
-    profile: z.string().optional(),
-    scopes: stringArray.optional(),
-    deprecated: z.boolean().optional(),
-    tokenRequired: z.boolean().optional(),
-    pathRestricted: z.boolean().optional(),
-    projectRestricted: z.boolean().optional()
-});
-export function readBridgeAuthority(metadata) {
-    const raw = metadata?.authority;
-    if (raw === undefined)
-        return undefined;
-    const parsed = bridgeAuthoritySchema.safeParse(raw);
-    return parsed.success ? parsed.data : undefined;
-}
-export const bridgeAckSchema = z.looseObject({
-    type: z.literal('bridge_ack'),
-    message: z.string().optional(),
-    serverName: z.string().optional(),
-    sessionId: z.string().optional(),
-    protocolVersion: nonNegativeInteger.optional(),
-    pluginVersion: z.string().optional(),
-    authority: bridgeAuthoritySchema.optional(),
-    contentRoots: stringArray.optional()
-});
-export const CONTENT_ROOTS_CHANGED_EVENT = 'content_roots_changed';
-export function readContentRoots(source) {
-    if (source === null || typeof source !== 'object' || Array.isArray(source))
-        return undefined;
-    return source.contentRoots;
-}
-export function pluginVersionMismatch(metadata) {
-    const plugin = metadata?.pluginVersion;
-    if (plugin === PACKAGE.version)
-        return undefined;
-    const server = `${PACKAGE.name} ${PACKAGE.version}`;
-    const install = `install the ${PACKAGE.version} plugin from ${RELEASE_TAG_URL}${PACKAGE.version} and restart the editor`;
-    return typeof plugin === 'string'
-        ? `Version mismatch: this server is ${server} but the editor runs McpAutomationBridge ${plugin}, so actions and parameters can differ. Fix: ${install}, or pin the server to the plugin with npx -y ${PACKAGE.name}@${plugin} and restart the MCP client.`
-        : `Version mismatch: this server is ${server} but the editor runs a McpAutomationBridge plugin that predates version reporting, so actions and parameters can differ. Fix: ${install}.`;
-}
-export const bridgeErrorSchema = z.looseObject({
-    type: z.literal('bridge_error'),
-    error: z.string().optional(),
-    message: z.string().optional()
-});
-export const progressUpdateSchema = z.looseObject({
-    type: z.literal('progress_update'),
-    requestId: z.string().min(1),
-    percent: z.number().min(0).max(100).optional(),
-    message: z.string().optional(),
-    timestamp: z.string().optional(),
-    stillWorking: z.boolean().optional()
-});
-export const cancelRequestSchema = z.looseObject({
-    type: z.literal('cancel_request'),
-    requestId: z.string().min(1),
-    reason: z.string().optional()
-});
-export const automationMessageSchema = z.discriminatedUnion('type', [
-    automationResponseSchema,
-    automationEventSchema,
-    bridgeAckSchema,
-    bridgeErrorSchema,
-    progressUpdateSchema,
-    cancelRequestSchema
-]);
-//# sourceMappingURL=message-schema.js.map

package/dist/automation/request-cancellation-error.d.ts

@@ -1,7 +0,0 @@
-export declare class McpRequestCancelledError extends Error {
-    readonly reason?: string | undefined;
-    readonly code = "MCP_REQUEST_CANCELLED";
-    readonly cancelled = true;
-    constructor(message: string, reason?: string | undefined);
-}
-//# sourceMappingURL=request-cancellation-error.d.ts.map