unreal-engine-mcp-server 0.4.7 → 0.5.0

package/plugins/McpAutomationBridge/Source/McpAutomationBridge/Public/McpConnectionManager.h

@@ -0,0 +1,117 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Containers/Ticker.h"
+#include "Dom/JsonObject.h"
+#include "Templates/SharedPointer.h"
+#include "Misc/ScopeLock.h"
+
+class FMcpBridgeWebSocket;
+class UMcpAutomationBridgeSettings;
+
+/**
+ * Delegate for handling incoming automation requests.
+ * Params: RequestId, Action, Payload, RequestingSocket
+ */
+DECLARE_DELEGATE_FourParams(FMcpMessageReceivedCallback, const FString&, const FString&, const TSharedPtr<FJsonObject>&, TSharedPtr<FMcpBridgeWebSocket>);
+
+/**
+ * Manages WebSocket connections for the MCP Automation Bridge.
+ * Handles listening, connecting, reconnecting, heartbeats, and message dispatching.
+ */
+class MCPAUTOMATIONBRIDGE_API FMcpConnectionManager : public TSharedFromThis<FMcpConnectionManager>
+{
+public:
+	FMcpConnectionManager();
+	~FMcpConnectionManager();
+
+	void Initialize(const UMcpAutomationBridgeSettings* Settings);
+	void Start();
+	void Stop();
+
+	bool IsConnected() const;
+	bool IsBridgeActive() const { return bBridgeAvailable; }
+
+	bool SendRawMessage(const FString& Message);
+	void SendAutomationResponse(TSharedPtr<FMcpBridgeWebSocket> TargetSocket, const FString& RequestId, bool bSuccess, const FString& Message, const TSharedPtr<FJsonObject>& Result, const FString& ErrorCode);
+	void SendControlMessage(const TSharedPtr<FJsonObject>& Message);
+
+	void SetOnMessageReceived(FMcpMessageReceivedCallback InCallback);
+
+	// Request tracking helpers
+	int32 GetActiveSocketCount() const;
+	void RegisterRequestSocket(const FString& RequestId, TSharedPtr<FMcpBridgeWebSocket> Socket);
+
+	// Telemetry helpers
+	void StartRequestTelemetry(const FString& RequestId, const FString& Action);
+	void RecordAutomationTelemetry(const FString& RequestId, bool bSuccess, const FString& Message, const FString& ErrorCode);
+
+	bool Tick(float DeltaTime);
+
+private:
+	void AttemptConnection();
+	void ForceReconnect(const FString& Reason, float ReconnectDelayOverride = -1.0f);
+
+	void HandleConnected(TSharedPtr<FMcpBridgeWebSocket> Socket);
+	void HandleClientConnected(TSharedPtr<FMcpBridgeWebSocket> ClientSocket);
+	void HandleConnectionError(TSharedPtr<FMcpBridgeWebSocket> Socket, const FString& Error);
+	void HandleServerConnectionError(const FString& Error);
+	void HandleClosed(TSharedPtr<FMcpBridgeWebSocket> Socket, int32 StatusCode, const FString& Reason, bool bWasClean);
+	void HandleMessage(TSharedPtr<FMcpBridgeWebSocket> Socket, const FString& Message);
+	void HandleHeartbeat(TSharedPtr<FMcpBridgeWebSocket> Socket);
+
+	void EmitAutomationTelemetrySummaryIfNeeded(double NowSeconds);
+
+private:
+	TArray<TSharedPtr<FMcpBridgeWebSocket>> ActiveSockets;
+	TMap<FString, TSharedPtr<FMcpBridgeWebSocket>> PendingRequestsToSockets;
+	FTSTicker::FDelegateHandle TickerHandle;
+	FMcpMessageReceivedCallback OnMessageReceived;
+
+	// Configuration
+	FString EnvListenHost;
+	FString EnvListenPorts;
+	FString EndpointUrl;
+	FString CapabilityToken;
+	FString ServerName;
+	FString ServerVersion;
+	FString ActiveSessionId;
+	
+	int32 ClientPort = 0;
+	float AutoReconnectDelaySeconds = 5.0f;
+	float HeartbeatTimeoutSeconds = 0.0f;
+	
+	bool bRequireCapabilityToken = false;
+	bool bEnvListenPortsSet = false;
+	bool bHeartbeatTrackingEnabled = false;
+
+	// State
+	bool bBridgeAvailable = false;
+	bool bReconnectEnabled = true;
+	float TimeUntilReconnect = 0.0f;
+	double LastHeartbeatTimestamp = 0.0;
+
+	// Telemetry
+	struct FAutomationRequestTelemetry
+	{
+		FString Action;
+		double StartTimeSeconds = 0.0;
+	};
+
+	struct FAutomationActionStats
+	{
+		int32 SuccessCount = 0;
+		int32 FailureCount = 0;
+		double TotalSuccessDurationSeconds = 0.0;
+		double TotalFailureDurationSeconds = 0.0;
+		double LastDurationSeconds = 0.0;
+		double LastUpdatedSeconds = 0.0;
+	};
+
+	TMap<FString, FAutomationRequestTelemetry> ActiveRequestTelemetry;
+	TMap<FString, FAutomationActionStats> AutomationActionTelemetry;
+	double TelemetrySummaryIntervalSeconds = 120.0;
+	double LastTelemetrySummaryLogSeconds = 0.0;
+
+	mutable FCriticalSection PendingRequestsMutex;
+};

package/scripts/check-unreal-connection.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import net from 'node:net';
+
+const HOST = process.env.MCP_AUTOMATION_WS_HOST || '127.0.0.1';
+const PORT = process.env.MCP_AUTOMATION_WS_PORT ? parseInt(process.env.MCP_AUTOMATION_WS_PORT) : 8091;
+console.log(`Checking connection to Unreal Engine on port ${PORT}...`);
+
+function check(host, port, timeoutMs = 2000) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => { try { socket.destroy(); } catch {} resolve(false); }, timeoutMs);
+    socket.once('error', () => { clearTimeout(timer); resolve(false); });
+    socket.connect(port, host, () => { clearTimeout(timer); try { socket.destroy(); } catch {} resolve(true); });
+  });
+}
+
+const ok = await check(HOST, PORT);
+console.log(ok ? `OK: ${HOST}:${PORT} accepting TCP` : `DOWN: ${HOST}:${PORT} not reachable`);
+process.exit(ok ? 0 : 1);

package/scripts/clean-tmp.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const TMP_DIR = path.resolve(__dirname, '..', 'tmp');
+if (!fs.existsSync(TMP_DIR)) {
+  console.log('No tmp directory present.');
+  process.exit(0);
+}
+
+for (const f of fs.readdirSync(TMP_DIR)) {
+  const p = path.join(TMP_DIR, f);
+  try {
+    fs.unlinkSync(p);
+    console.log('Removed', p);
+  } catch (e) {
+    console.warn('Failed to remove', p, e.message || e);
+  }
+}
+console.log('tmp cleanup complete.');

package/scripts/patch-wasm.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const wasmPkgPath = path.resolve(__dirname, '../src/wasm/pkg/unreal_mcp_wasm.js');
+
+try {
+    if (fs.existsSync(wasmPkgPath)) {
+        let content = fs.readFileSync(wasmPkgPath, 'utf8');
+        if (content.includes('console.log(getObject(arg0));')) {
+            content = content.replace('console.log(getObject(arg0));', 'console.error(getObject(arg0));');
+            fs.writeFileSync(wasmPkgPath, content);
+            console.log('Successfully patched console.log to console.error in WASM bindings.');
+        } else {
+            console.log('WASM bindings already patched or console.log not found.');
+        }
+    } else {
+        console.warn('WASM binding file not found at:', wasmPkgPath);
+    }
+} catch (error) {
+    console.error('Error patching WASM bindings:', error);
+    process.exit(1);
+}

package/scripts/run-all-tests.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+
+const tests = [
+  'test:control_actor', // Pass
+  'test:control_editor', // Pass
+  'test:manage_level', // Pass
+  'test:animation', // Pass
+  'test:materials', // Pass
+  'test:niagara', // Pass
+  'test:landscape', // Pass
+  'test:sequence', // Pass
+  'test:system', // Pass
+  'test:console_command', // Pass
+  'test:inspect', // Pass
+  'test:manage_asset', // Pass
+  'test:blueprint', // Pass
+  'test:blueprint_graph', // Pass
+  // 'test:graphql', // Pass
+  'test:wasm:all', // Pass
+  'test:no-inline-python',
+  'test:plugin-handshake', // Pass
+  'test:asset_advanced', // Pass
+  'test:render', // Pass
+  'test:world_partition' // Pass
+];
+
+const isWindows = process.platform === 'win32';
+const npmExecPath = process.env.npm_execpath;
+const npmCommand = isWindows ? 'npm.cmd' : 'npm';
+
+function spawnNpm(cmd) {
+  if (npmExecPath && npmExecPath.endsWith('.js')) {
+    return spawn(process.execPath, [npmExecPath, 'run', cmd], {
+      stdio: 'inherit',
+      cwd: process.cwd(),
+      env: process.env,
+      windowsHide: true
+    });
+  }
+  return spawn(npmCommand, ['run', cmd], {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: process.env,
+    windowsHide: true
+  });
+}
+
+function runOne(cmd) {
+  return new Promise((resolve) => {
+    const startedAt = Date.now();
+    const child = spawnNpm(cmd);
+
+    let errorMsg = '';
+    child.on('error', (err) => {
+      errorMsg = `Failed to launch npm run ${cmd}: ${err.message}`;
+    });
+
+    child.on('exit', (code, signal) => {
+      const durationMs = Date.now() - startedAt;
+      if (signal) {
+        resolve({ name: cmd, ok: false, code: null, signal, durationMs, error: `${cmd} terminated via signal ${signal}` });
+      } else {
+        resolve({ name: cmd, ok: code === 0, code, signal: null, durationMs, error: code === 0 ? null : (errorMsg || `${cmd} failed with code ${code}`) });
+      }
+    });
+
+    const forwardSignal = (sig) => {
+      if (child.killed) return;
+      child.kill(sig);
+    };
+
+    process.once('SIGTERM', forwardSignal);
+
+    child.once('exit', () => {
+      process.removeListener('SIGINT', forwardSignal);
+      process.removeListener('SIGTERM', forwardSignal);
+    });
+  });
+}
+
+(async () => {
+  // Pass 0: Build once
+  console.log('\n============================================================');
+  console.log('Running Pre-Test Build');
+  console.log('============================================================');
+
+  // Use runOne to execute the build command
+  // We can't use npm run build directly if it's not in the 'tests' array, so let's just trigger it.
+  const buildRes = await runOne('build');
+  if (!buildRes.ok) {
+    console.error(`\nBuild failed (code=${buildRes.code ?? 'n/a'}). Aborting tests.`);
+    process.exit(1);
+  }
+  console.log('Build completed successfully. Disabling auto-build for tests.');
+
+  // Set the environment variable to disable auto-build for subsequent tests
+  process.env.UNREAL_MCP_NO_AUTO_BUILD = '1';
+  // Force use of the just-built dist folder to prevent falling back to ts-node
+  // (which can happen if build:wasm updates timestamps in src/ after build:core)
+  process.env.UNREAL_MCP_FORCE_DIST = '1';
+
+  const results = [];
+  for (const t of tests) {
+    const res = await runOne(t);
+    results.push(res);
+    if (!res.ok) {
+      console.error(`\n${t} failed (code=${res.code ?? 'n/a'}, signal=${res.signal ?? 'n/a'}) after ${res.durationMs}ms`);
+      if (res.error) console.error(res.error);
+    }
+  }
+
+  // Summary
+  const passed = results.filter(r => r.ok).length;
+  const failed = results.length - passed;
+  console.log('\n============================================================');
+  console.log('Test Suite Summary');
+  console.log('============================================================');
+  for (const r of results) {
+    const status = r.ok ? 'PASSED' : 'FAILED';
+    console.log(`${status} - ${r.name} (${r.durationMs} ms)`);
+  }
+  console.log('------------------------------------------------------------');
+  console.log(`Total: ${results.length}  Passed: ${passed}  Failed: ${failed}`);
+  console.log('============================================================');
+
+  process.exit(failed > 0 ? 1 : 0);
+})().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/scripts/smoke-test.ts

@@ -0,0 +1,94 @@
+
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const serverPath = path.join(__dirname, '../dist/cli.js');
+
+console.log('🚬 Running Smoke Test (Mock Mode)...');
+console.log(`🔌 Server Path: ${serverPath}`);
+
+const env = { ...process.env, MOCK_UNREAL_CONNECTION: 'true' };
+
+const child = spawn('node', [serverPath], {
+    env,
+    stdio: ['pipe', 'pipe', 'inherit'] // pipe stdin/stdout, inherit stderr
+});
+
+const requests = [
+    {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'smoke-test', version: '1.0' }
+        }
+    },
+    {
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'tools/list',
+        params: {}
+    }
+];
+
+let buffer = '';
+let passed = false;
+
+child.stdout.on('data', (data) => {
+    const chunk = data.toString();
+    buffer += chunk;
+
+    // Try to parse JSON lines
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || ''; // Keep the incomplete last line
+
+    for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+            const msg = JSON.parse(line);
+            console.log('Received:', JSON.stringify(msg).substring(0, 100) + '...');
+
+            if (msg.id === 1 && msg.result) {
+                console.log('✅ Initialize success');
+                // Send list tools request
+                child.stdin.write(JSON.stringify(requests[1]) + '\n');
+            }
+
+            if (msg.id === 2 && msg.result) {
+                console.log(`✅ Tools check success: Found ${msg.result.tools?.length || 0} tools`);
+                passed = true;
+                child.kill();
+            }
+
+        } catch (_e) {
+            // Ignore non-JSON output (logs)
+        }
+    }
+});
+
+child.on('exit', (_code) => {
+    if (passed) {
+        console.log('🎉 Smoke Test PASSED');
+        process.exit(0);
+    } else {
+        console.error('❌ Smoke Test FAILED - Server exited without passing checks');
+        process.exit(1);
+    }
+});
+
+// Start by sending initialize
+console.log('Sending initialize...');
+child.stdin.write(JSON.stringify(requests[0]) + '\n');
+
+// Timeout safety
+setTimeout(() => {
+    if (!passed) {
+        console.error('❌ Timeout waiting for smoke test');
+        child.kill();
+        process.exit(1);
+    }
+}, 10000);

package/scripts/sync-mcp-plugin.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SOURCE_RELATIVE = ['..', 'plugins', 'McpAutomationBridge'];
+const sourceDir = path.resolve(__dirname, ...SOURCE_RELATIVE);
+
+function showHelp() {
+  const scriptName = path.basename(process.argv[1]);
+  console.log(`Usage: node ${scriptName} [--engine <engine_plugins_dir>] [--project <project_plugins_dir>] [--dry-run] [--clean-engine] [--clean-project]`);
+  console.log('Copies the MCP Automation Bridge plugin from this repository into Engine and/or Project plugin directories.');
+  console.log('--engine <dir>         Path to the Engine/Plugins directory (the script appends McpAutomationBridge automatically).');
+  console.log('--project <dir>        Path to the Project/Plugins directory (the script appends McpAutomationBridge automatically).');
+  console.log('--dry-run              Log the operations without modifying the filesystem.');
+  console.log('--clean-engine         Remove the destination engine plugin directory before copying.');
+  console.log('--clean-project        Remove the destination project plugin directory before copying.');
+  console.log('--help                 Show this message.');
+}
+
+function parseArgs(argv) {
+  const args = {
+    engine: null,
+    project: null,
+    dryRun: false,
+    cleanEngine: false,
+    cleanProject: false,
+    help: false
+  };
+
+  for (let i = 2; i < argv.length; i += 1) {
+    const token = argv[i];
+    switch (token) {
+      case '--engine':
+        args.engine = argv[++i];
+        break;
+      case '--project':
+        args.project = argv[++i];
+        break;
+      case '--dry-run':
+        args.dryRun = true;
+        break;
+      case '--clean-engine':
+        args.cleanEngine = true;
+        break;
+      case '--clean-project':
+        args.cleanProject = true;
+        break;
+      case '--help':
+      case '-h':
+        args.help = true;
+        break;
+      default:
+        console.error(`Unknown argument: ${token}`);
+        args.help = true;
+        break;
+    }
+  }
+
+  return args;
+}
+
+function ensureSourceExists() {
+  if (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory()) {
+    throw new Error(`Source directory missing: ${sourceDir}`);
+  }
+}
+
+function resolveDestination(rootDir, label) {
+  if (!rootDir) {
+    return null;
+  }
+
+  const fullPath = path.resolve(rootDir, 'McpAutomationBridge');
+  if (!fs.existsSync(path.dirname(fullPath))) {
+    throw new Error(`Destination parent directory does not exist for ${label}: ${path.dirname(fullPath)}`);
+  }
+
+  return fullPath;
+}
+
+function removeDir(targetPath, dryRun) {
+  if (!fs.existsSync(targetPath)) {
+    return;
+  }
+
+  if (dryRun) {
+    console.log(`[dry-run] Would remove directory: ${targetPath}`);
+    return;
+  }
+
+  fs.rmSync(targetPath, { recursive: true, force: true });
+  console.log(`Removed existing directory: ${targetPath}`);
+}
+
+function copyDir(targetPath, dryRun) {
+  if (dryRun) {
+    console.log(`[dry-run] Would copy ${sourceDir} -> ${targetPath}`);
+    return;
+  }
+
+  fs.cpSync(sourceDir, targetPath, { recursive: true });
+  console.log(`Copied ${sourceDir} -> ${targetPath}`);
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  if (args.help || (!args.engine && !args.project)) {
+    showHelp();
+    return;
+  }
+
+  ensureSourceExists();
+
+  if (args.engine) {
+    const engineDest = resolveDestination(args.engine, 'engine');
+    if (args.cleanEngine) {
+      removeDir(engineDest, args.dryRun);
+    }
+    copyDir(engineDest, args.dryRun);
+  }
+
+  if (args.project) {
+    const projectDest = resolveDestination(args.project, 'project');
+    if (args.cleanProject) {
+      removeDir(projectDest, args.dryRun);
+    }
+    copyDir(projectDest, args.dryRun);
+  }
+
+  console.log('Done. Remember to clear the plugin Binaries/Intermediate folders if requested by Unreal.');
+}
+
+try {
+  main();
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exitCode = 1;
+}

package/scripts/test-no-plugin-alternates.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..');
+const srcRoot = path.resolve(repoRoot, 'src');
+
+function isPositionInsideLiteralOrComment(content, pos) {
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let i = 0; i < pos; i += 1) {
+    const ch = content[i];
+    const next = content[i + 1];
+
+    if (inLineComment) {
+      if (ch === '\n') inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === '*' && next === '/') {
+        inBlockComment = false; i += 1; continue;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === "'") { inSingle = false; }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === '"') { inDouble = false; }
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === '`') { inBacktick = false; }
+      continue;
+    }
+
+    if (ch === '/' && next === '/') { inLineComment = true; i += 1; continue; }
+    if (ch === '/' && next === '*') { inBlockComment = true; i += 1; continue; }
+    if (ch === "'") { inSingle = true; continue; }
+    if (ch === '"') { inDouble = true; continue; }
+    if (ch === '`') { inBacktick = true; continue; }
+  }
+
+  return inSingle || inDouble || inBacktick || inLineComment || inBlockComment;
+}
+
+async function listTsFiles(dir) {
+  const out = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    if (ent.name === 'node_modules' || ent.name === 'dist' || ent.name === '.git') continue;
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      out.push(...(await listTsFiles(full)));
+    } else if (ent.isFile() && full.endsWith('.ts')) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function toLineCol(content, index) {
+  const before = content.slice(0, index);
+  const lines = before.split(/\r?\n/);
+  const line = lines.length;
+  const col = lines[lines.length - 1].length + 1;
+  return { line, col };
+}
+
+async function main() {
+  const pattern = /simulated\s*:/g;
+  const files = await listTsFiles(srcRoot);
+  const failures = [];
+
+  for (const f of files) {
+    const content = await fs.readFile(f, 'utf8');
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+      const idx = m.index;
+      if (isPositionInsideLiteralOrComment(content, idx)) continue;
+      const pos = toLineCol(content, idx);
+      const snippetLine = content.split(/\r?\n/)[pos.line - 1] ?? '';
+      failures.push({ file: f, line: pos.line, col: pos.col, snippet: snippetLine.trim() });
+    }
+  }
+
+  if (failures.length > 0) {
+    console.error('\nDetected per-tool "simulated" alternatives usages in TypeScript files:');
+    for (const fail of failures) {
+      console.error(`\n - ${path.relative(repoRoot, fail.file)}:${fail.line}:${fail.col}  -> ${fail.snippet}`);
+    }
+    console.error('\nPer-tool simulated alternatives are disallowed. Replace simulated behavior with explicit plugin actions or return an explicit error (e.g. MISSING_ENGINE_PLUGINS).');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('No per-tool plugin "simulated" alternatives found in TypeScript source files.');
+}
+
+main().catch((err) => {
+  console.error('Test failed with unexpected error:', err);
+  process.exitCode = 2;
+});