blueprint-extractor-mcp 2.2.0 → 2.3.0

package/dist/project-controller.d.ts

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 export type BuildPlatform = 'Win64' | 'Mac' | 'Linux';
 export type BuildConfiguration = 'Debug' | 'DebugGame' | 'Development' | 'Shipping' | 'Test';
 export type SyncStrategy = 'live_coding' | 'build_and_restart';
@@ -11,6 +12,11 @@ export interface CompileProjectCodeRequest {
     includeOutput?: boolean;
     clearUhtCache?: boolean;
 }
+export interface LaunchEditorRequest {
+    engineRoot?: string;
+    projectPath?: string;
+    additionalArgs?: string[];
+}
 export interface SyncProjectCodeRequest extends CompileProjectCodeRequest {
     changedPaths: string[];
     forceRebuild?: boolean;
@@ -58,6 +64,19 @@ export interface RestartReconnectResult {
     reconnectTimeoutMs: number;
     diagnostics: string[];
 }
+export interface LaunchEditorResult {
+    success: boolean;
+    operation: 'launch_editor';
+    engineRoot: string;
+    projectPath: string;
+    projectDir: string;
+    command: {
+        executable: string;
+        args: string[];
+    };
+    detached: boolean;
+    diagnostics: string[];
+}
 export type ProbeConnection = (() => Promise<boolean>) | null;
 export interface CommandInvocation {
     executable: string;
@@ -78,18 +97,23 @@ export interface ProjectControllerOptions {
     env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     runCommand?: CommandRunner;
+    spawnProcess?: typeof spawn;
     sleep?: (ms: number) => Promise<void>;
 }
 export interface ProjectControllerLike {
     readonly liveCodingSupported: boolean;
     classifyChangedPaths(changedPaths: string[], forceRebuild?: boolean): SyncStrategyPlan;
     compileProjectCode(request: CompileProjectCodeRequest): Promise<CompileProjectCodeResult>;
+    launchEditor(request: LaunchEditorRequest): Promise<LaunchEditorResult>;
     waitForEditorRestart(probeConnection: ProbeConnection, options?: {
         disconnectTimeoutMs?: number;
         reconnectTimeoutMs?: number;
+        waitForDisconnect?: boolean;
+        waitForReconnect?: boolean;
     }): Promise<RestartReconnectResult>;
 }
 export declare function resolveCommandInvocation(executable: string, args: string[], platform: NodeJS.Platform, env?: NodeJS.ProcessEnv): CommandInvocation;
+export declare function resolveEditorExecutable(engineRoot: string, platform: NodeJS.Platform, mode?: 'editor' | 'commandlet'): Promise<string>;
 export declare function classifyChangedPaths(changedPaths: string[], forceRebuild?: boolean): SyncStrategyPlan;
 /** Classify UBT build output into an error category. */
 export declare function classifyBuildError(stdout: string, stderr: string, exitCode: number): {
@@ -101,13 +125,17 @@ export declare class ProjectController implements ProjectControllerLike {
     private readonly env;
     private readonly platform;
     private readonly runCommand;
+    private readonly spawnProcess;
     private readonly sleep;
     constructor(options?: ProjectControllerOptions);
     get liveCodingSupported(): boolean;
     classifyChangedPaths(changedPaths: string[], forceRebuild?: boolean): SyncStrategyPlan;
     compileProjectCode(request: CompileProjectCodeRequest): Promise<CompileProjectCodeResult>;
+    launchEditor(request: LaunchEditorRequest): Promise<LaunchEditorResult>;
     waitForEditorRestart(probeConnection: ProbeConnection, options?: {
         disconnectTimeoutMs?: number;
         reconnectTimeoutMs?: number;
+        waitForDisconnect?: boolean;
+        waitForReconnect?: boolean;
     }): Promise<RestartReconnectResult>;
 }

package/dist/project-controller.js

@@ -38,6 +38,18 @@ export function resolveCommandInvocation(executable, args, platform, env = proce
         args: ['/d', '/s', '/c', commandLine],
     };
 }
+export async function resolveEditorExecutable(engineRoot, platform, mode = 'editor') {
+    const executableName = mode === 'commandlet'
+        ? (platform === 'win32' ? 'UnrealEditor-Cmd.exe' : 'UnrealEditor-Cmd')
+        : (platform === 'win32' ? 'UnrealEditor.exe' : 'UnrealEditor');
+    const executable = platform === 'win32'
+        ? resolve(engineRoot, 'Engine', 'Binaries', 'Win64', executableName)
+        : platform === 'darwin'
+            ? resolve(engineRoot, 'Engine', 'Binaries', 'Mac', executableName)
+            : resolve(engineRoot, 'Engine', 'Binaries', 'Linux', executableName);
+    await access(executable, fsConstants.F_OK);
+    return executable;
+}
 async function defaultRunCommand(executable, args, options) {
     return await new Promise((resolveRun, rejectRun) => {
         const invocation = resolveCommandInvocation(executable, args, process.platform, options.env ?? process.env);
@@ -276,11 +288,13 @@ export class ProjectController {
     env;
     platform;
     runCommand;
+    spawnProcess;
     sleep;
     constructor(options = {}) {
         this.env = options.env ?? process.env;
         this.platform = parsePlatform(options.platform, process.platform);
         this.runCommand = options.runCommand ?? defaultRunCommand;
+        this.spawnProcess = options.spawnProcess ?? spawn;
         this.sleep = options.sleep ?? defaultSleep;
     }
     get liveCodingSupported() {
@@ -369,12 +383,52 @@ export class ProjectController {
         }
         return result;
     }
+    async launchEditor(request) {
+        const engineRoot = request.engineRoot ?? this.env.UE_ENGINE_ROOT;
+        const projectPath = request.projectPath ?? this.env.UE_PROJECT_PATH;
+        const diagnostics = [];
+        if (!engineRoot) {
+            throw new Error('launch_editor requires engine_root or UE_ENGINE_ROOT');
+        }
+        if (!projectPath) {
+            throw new Error('launch_editor requires project_path or UE_PROJECT_PATH');
+        }
+        const executable = await resolveEditorExecutable(engineRoot, this.platform, 'editor');
+        const args = [projectPath, ...(request.additionalArgs ?? [])];
+        const invocation = resolveCommandInvocation(executable, args, this.platform, this.env);
+        const child = this.spawnProcess(invocation.executable, invocation.args, {
+            cwd: dirname(projectPath),
+            env: this.env,
+            shell: false,
+            windowsVerbatimArguments: isWindowsBatchScript(executable, this.platform),
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+        return {
+            success: true,
+            operation: 'launch_editor',
+            engineRoot,
+            projectPath,
+            projectDir: dirname(projectPath),
+            command: {
+                executable: invocation.executable,
+                args: invocation.args,
+            },
+            detached: true,
+            diagnostics,
+        };
+    }
     async waitForEditorRestart(probeConnection, options = {}) {
         const disconnectTimeoutMs = options.disconnectTimeoutMs ?? DEFAULT_DISCONNECT_TIMEOUT_MS;
         const reconnectTimeoutMs = options.reconnectTimeoutMs ?? DEFAULT_RECONNECT_TIMEOUT_MS;
+        const waitForDisconnect = options.waitForDisconnect ?? true;
+        const waitForReconnect = options.waitForReconnect ?? true;
         const diagnostics = [];
-        const disconnected = await waitForState(probeConnection, false, disconnectTimeoutMs, this.sleep);
-        if (!disconnected) {
+        const disconnected = waitForDisconnect
+            ? await waitForState(probeConnection, false, disconnectTimeoutMs, this.sleep)
+            : false;
+        if (waitForDisconnect && !disconnected) {
             diagnostics.push('Editor never disconnected after restart request');
             return {
                 success: false,
@@ -386,14 +440,16 @@ export class ProjectController {
                 diagnostics,
             };
         }
-        const reconnected = await waitForState(probeConnection, true, reconnectTimeoutMs, this.sleep);
-        if (!reconnected) {
+        const reconnected = waitForReconnect
+            ? await waitForState(probeConnection, true, reconnectTimeoutMs, this.sleep)
+            : false;
+        if (waitForReconnect && !reconnected) {
             diagnostics.push('Editor did not reconnect before the timeout elapsed');
         }
         return {
-            success: reconnected,
+            success: (waitForDisconnect ? disconnected : true) && (waitForReconnect ? reconnected : true),
             operation: 'restart_editor',
-            disconnected: true,
+            disconnected,
             reconnected,
             disconnectTimeoutMs,
             reconnectTimeoutMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blueprint-extractor-mcp",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "MCP server for the Unreal Engine BlueprintExtractor plugin over Remote Control",
   "type": "module",
   "main": "dist/index.js",