@createlex/createlexgenai 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@createlex/createlexgenai",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "CLI tool and MCP server for CreatelexGenAI — Unreal Engine AI integration",
   "bin": {
     "createlex": "./bin/createlex.js"

package/src/core/unreal-connection.js

@@ -171,14 +171,18 @@ async function executeWithBackend(toolName, params = {}, options = {}) {
 
   if (backend === BACKEND.WEB_REMOTE) {
     // Web Remote Control — translate tool calls to HTTP API calls
+    // Don't pass plugin port to web remote; let it use its own default (30010)
     const webRemote = require('./web-remote-control');
-    return executeViaWebRemote(webRemote, toolName, params, options);
+    const webOpts = { ...options, port: options.webRemotePort || undefined };
+    return executeViaWebRemote(webRemote, toolName, params, webOpts);
   }
 
   if (backend === BACKEND.REMOTE_EXEC) {
     // Python Remote Execution — generate Python code and execute
+    // Don't pass plugin port to remote exec; it uses UDP multicast
     const remoteExec = require('./remote-execution');
-    return executeViaRemoteExec(remoteExec, toolName, params, options);
+    const execOpts = { ...options, port: undefined };
+    return executeViaRemoteExec(remoteExec, toolName, params, execOpts);
   }
 
   // Auto-detect
@@ -196,9 +200,6 @@ async function executeWithBackend(toolName, params = {}, options = {}) {
 async function executeViaWebRemote(webRemote, toolName, params, options) {
   // Map common tool names to Web Remote Control API calls
   switch (toolName) {
-    case 'get_all_scene_objects':
-      return webRemote.getAllLevelActors(options);
-
     case 'execute_python_script':
       return webRemote.executePythonScript(params.script, options);
 
@@ -206,12 +207,10 @@ async function executeViaWebRemote(webRemote, toolName, params, options) {
       return webRemote.executeConsoleCommand(params.command, options);
 
     default: {
-      // For tools that don't have a direct mapping, try to execute via Python
+      // For all tools (including get_all_scene_objects, spawn_object, etc.),
+      // generate standalone UE Python and execute via Python subsystem
       const script = buildPythonForTool(toolName, params);
-      if (script) {
-        return webRemote.executePythonScript(script, options);
-      }
-      throw new Error(`Tool '${toolName}' is not supported via Web Remote Control. Use the CreatelexGenAI plugin for full tool access.`);
+      return webRemote.executePythonScript(script, options);
     }
   }
 }
@@ -238,7 +237,7 @@ async function executeViaRemoteExec(remoteExec, toolName, params, options) {
     case 'get_all_scene_objects': {
       const pyCode = `
 import unreal, json
-actors = unreal.EditorLevelLibrary.get_all_level_actors()
+actors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
 result = [{"name": a.get_actor_label(), "class": a.get_class().get_name(), "location": [a.get_actor_location().x, a.get_actor_location().y, a.get_actor_location().z]} for a in actors]
 print(json.dumps(result))
 `;
@@ -257,7 +256,7 @@ import unreal, json
 loc = ${loc}
 rot = ${rot}
 scale = ${scale}
-actor = unreal.EditorLevelLibrary.spawn_actor_from_class(unreal.EditorAssetLibrary.load_asset('/Script/Engine.${params.actor_class}').get_class(), unreal.Vector(*loc), unreal.Rotator(*rot))
+actor = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).spawn_actor_from_class(unreal.EditorAssetLibrary.load_asset('/Script/Engine.${params.actor_class}').get_class(), unreal.Vector(*loc), unreal.Rotator(*rot))
 if actor:
     actor.set_actor_scale3d(unreal.Vector(*scale))
     ${params.actor_label ? `actor.set_actor_label("${params.actor_label}")` : ''}
@@ -285,26 +284,127 @@ else:
 }
 
 /**
- * Build a generic Python script to execute a tool by name.
- * Falls back to importing from the MCP server module if available.
+ * Build a standalone UE Python script to execute a tool by name.
+ * These scripts use only the `unreal` module available inside UE's Python interpreter.
  */
 function buildPythonForTool(toolName, params) {
-  // Generic approach: serialize params and call the tool function in the MCP server
-  // This works if the mcp_server_stdio.py module is importable
-  const paramsJson = JSON.stringify(params).replace(/"/g, '\\"');
-
-  return `
-import json, sys
-try:
-    # Try to call the tool function directly
-    from mcp_server_stdio import ${toolName}
-    result = ${toolName}(**json.loads("${paramsJson}"))
-    print(result if isinstance(result, str) else json.dumps(result))
-except ImportError:
-    print(json.dumps({"error": "Tool '${toolName}' requires the CreatelexGenAI plugin or MCP server."}))
-except Exception as e:
-    print(json.dumps({"error": str(e)}))
-`;
+  const paramsJson = JSON.stringify(params);
+
+  switch (toolName) {
+    case 'spawn_object': {
+      const actorClass = params.actor_class || 'StaticMeshActor';
+      const loc = params.location || '0,0,0';
+      const rot = params.rotation || '0,0,0';
+      const scale = params.scale || '1,1,1';
+      const label = params.actor_label || '';
+      const locParts = loc.split(',').map(s => s.trim());
+      const rotParts = rot.split(',').map(s => s.trim());
+      const scaleParts = scale.split(',').map(s => s.trim());
+      return `import unreal, json
+actor = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).spawn_actor_from_class(unreal.${actorClass}, unreal.Vector(${locParts.join(',')}), unreal.Rotator(${rotParts.join(',')}))
+if actor:
+    actor.set_actor_scale3d(unreal.Vector(${scaleParts.join(',')}))
+    ${label ? `actor.set_actor_label("${label}")` : ''}
+    mesh_path = '/Engine/BasicShapes/Cube'
+    if hasattr(actor, 'static_mesh_component'):
+        mesh = unreal.EditorAssetLibrary.load_asset(mesh_path)
+        if mesh:
+            actor.static_mesh_component.set_static_mesh(mesh)
+    print(json.dumps({"success": True, "actor": actor.get_actor_label(), "class": "${actorClass}"}))
+else:
+    print(json.dumps({"success": False, "error": "Failed to spawn ${actorClass}"}))`;
+    }
+
+    case 'delete_actor': {
+      const name = params.actor_name || params.name || '';
+      return `import unreal, json
+actors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
+deleted = []
+for a in actors:
+    if a.get_actor_label() == "${name}":
+        a.destroy_actor()
+        deleted.append("${name}")
+print(json.dumps({"success": len(deleted) > 0, "deleted": deleted}))`;
+    }
+
+    case 'find_actors_by_name': {
+      const pattern = params.pattern || params.name || '';
+      return `import unreal, json
+actors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
+found = []
+for a in actors:
+    label = a.get_actor_label()
+    if "${pattern}".lower() in label.lower():
+        loc = a.get_actor_location()
+        found.append({"name": label, "class": a.get_class().get_name(), "location": [loc.x, loc.y, loc.z]})
+print(json.dumps({"success": True, "actors": found, "count": len(found)}))`;
+    }
+
+    case 'set_actor_transform': {
+      const name = params.actor_name || params.name || '';
+      const loc = params.location || '';
+      const rot = params.rotation || '';
+      const scale = params.scale || '';
+      return `import unreal, json
+actors = unreal.get_editor_subsystem(unreal.EditorActorSubsystem).get_all_level_actors()
+target = None
+for a in actors:
+    if a.get_actor_label() == "${name}":
+        target = a
+        break
+if target:
+    ${loc ? `target.set_actor_location(unreal.Vector(${loc}), False, False)` : '# no location change'}
+    ${rot ? `target.set_actor_rotation(unreal.Rotator(${rot}), False, False)` : '# no rotation change'}
+    ${scale ? `target.set_actor_scale3d(unreal.Vector(${scale}))` : '# no scale change'}
+    print(json.dumps({"success": True, "actor": "${name}"}))
+else:
+    print(json.dumps({"success": False, "error": "Actor '${name}' not found"}))`;
+    }
+
+    case 'create_blueprint': {
+      const name = params.name || 'NewBlueprint';
+      const parentClass = params.parent_class || 'Actor';
+      const path = params.path || '/Game/Blueprints';
+      return `import unreal, json
+factory = unreal.BlueprintFactory()
+factory.set_editor_property("parent_class", unreal.${parentClass})
+asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+bp = asset_tools.create_asset("${name}", "${path}", unreal.Blueprint, factory)
+if bp:
+    print(json.dumps({"success": True, "name": "${name}", "path": "${path}/${name}"}))
+else:
+    print(json.dumps({"success": False, "error": "Failed to create blueprint"}))`;
+    }
+
+    case 'create_material': {
+      const name = params.name || 'NewMaterial';
+      const path = params.path || '/Game/Materials';
+      return `import unreal, json
+factory = unreal.MaterialFactoryNew()
+asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
+mat = asset_tools.create_asset("${name}", "${path}", unreal.Material, factory)
+if mat:
+    print(json.dumps({"success": True, "name": "${name}", "path": "${path}/${name}"}))
+else:
+    print(json.dumps({"success": False, "error": "Failed to create material"}))`;
+    }
+
+    case 'get_all_scene_objects':
+      return `import unreal, json
+subsystem = unreal.get_editor_subsystem(unreal.EditorActorSubsystem)
+actors = subsystem.get_all_level_actors()
+result = []
+for a in actors:
+    loc = a.get_actor_location()
+    result.append({"name": a.get_actor_label(), "class": a.get_class().get_name(), "location": [loc.x, loc.y, loc.z]})
+print(json.dumps(result))`;
+
+    default:
+      // Generic: pass tool name and params as JSON, let a generic handler try
+      return `import unreal, json
+params = json.loads('${paramsJson.replace(/'/g, "\\'")}')
+print(json.dumps({"success": False, "error": "Tool '${toolName}' is not directly supported in no-plugin mode via CLI exec. Use 'createlex serve' with an AI tool for full 71-tool support."}))`;
+  }
 }
 
 module.exports = {

package/src/core/web-remote-control.js

@@ -15,12 +15,18 @@ function request(method, path, body = null, options = {}) {
   const timeout = options.timeout || REQUEST_TIMEOUT;
 
   return new Promise((resolve, reject) => {
+    const bodyStr = body ? JSON.stringify(body) : null;
+    const headers = { 'Content-Type': 'application/json' };
+    if (bodyStr) {
+      headers['Content-Length'] = Buffer.byteLength(bodyStr);
+    }
+
     const reqOptions = {
       hostname: host,
       port,
       path,
       method,
-      headers: { 'Content-Type': 'application/json' },
+      headers,
       timeout
     };
 
@@ -49,8 +55,8 @@ function request(method, path, body = null, options = {}) {
       }
     });
 
-    if (body) {
-      req.write(JSON.stringify(body));
+    if (bodyStr) {
+      req.write(bodyStr);
     }
 
     req.end();
@@ -184,7 +190,7 @@ async function executePythonScript(script, options = {}) {
     'ExecutePythonCommandEx',
     {
       PythonCommand: script,
-      ExecutionMode: 'EvaluateStatement',
+      ExecutionMode: 'ExecuteFile',
       FileExecutionScope: 'Public'
     },
     options