@createlex/createlexgenai 1.0.0

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

@@ -0,0 +1,243 @@
+'use strict';
+
+const http = require('http');
+
+const DEFAULT_HTTP_PORT = 30010;
+const DEFAULT_HOST = '127.0.0.1';
+const REQUEST_TIMEOUT = 15000;
+
+/**
+ * Make an HTTP request to the UE Web Remote Control API.
+ */
+function request(method, path, body = null, options = {}) {
+  const port = options.port || DEFAULT_HTTP_PORT;
+  const host = options.host || DEFAULT_HOST;
+  const timeout = options.timeout || REQUEST_TIMEOUT;
+
+  return new Promise((resolve, reject) => {
+    const reqOptions = {
+      hostname: host,
+      port,
+      path,
+      method,
+      headers: { 'Content-Type': 'application/json' },
+      timeout
+    };
+
+    const req = http.request(reqOptions, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          resolve({ status: res.statusCode, data: JSON.parse(data) });
+        } catch {
+          resolve({ status: res.statusCode, data: data || null });
+        }
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error(`Request timed out (port ${port})`));
+    });
+
+    req.on('error', (err) => {
+      if (err.code === 'ECONNREFUSED') {
+        reject(new Error(`Web Remote Control not available on port ${port}. Enable the "Web Remote Control" plugin in UE and run WebControl.StartServer.`));
+      } else {
+        reject(new Error(`HTTP error: ${err.message}`));
+      }
+    });
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * Health check — GET /remote/api/v1/health
+ */
+async function healthCheck(options = {}) {
+  try {
+    // Simple TCP connect test first (faster than full HTTP)
+    const net = require('net');
+    const port = options.port || DEFAULT_HTTP_PORT;
+    const host = options.host || DEFAULT_HOST;
+
+    const connected = await new Promise((resolve) => {
+      const socket = new net.Socket();
+      socket.setTimeout(3000);
+      socket.connect(port, host, () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.on('timeout', () => { socket.destroy(); resolve(false); });
+      socket.on('error', () => { socket.destroy(); resolve(false); });
+    });
+
+    if (!connected) {
+      return { available: false, error: `Port ${port} not reachable` };
+    }
+
+    // Full health check
+    const res = await request('GET', '/remote/api/v1/health', null, options);
+    return {
+      available: res.status === 200,
+      status: res.status,
+      data: res.data,
+      protocol: 'Web Remote Control (HTTP)',
+      port
+    };
+  } catch (err) {
+    return { available: false, error: err.message };
+  }
+}
+
+/**
+ * Call a UObject function.
+ *
+ * PUT /remote/object/call
+ * { objectPath, functionName, parameters, generateTransaction }
+ */
+async function callFunction(objectPath, functionName, parameters = {}, options = {}) {
+  const body = {
+    objectPath,
+    functionName,
+    parameters,
+    generateTransaction: options.generateTransaction || false
+  };
+
+  const res = await request('PUT', '/remote/object/call', body, options);
+  return res.data;
+}
+
+/**
+ * Get a UObject property.
+ *
+ * PUT /remote/object/property  (with READ_ACCESS)
+ */
+async function getProperty(objectPath, propertyName, options = {}) {
+  const body = {
+    objectPath,
+    propertyName,
+    access: 'READ_ACCESS'
+  };
+
+  const res = await request('PUT', '/remote/object/property', body, options);
+  return res.data;
+}
+
+/**
+ * Set a UObject property.
+ *
+ * PUT /remote/object/property
+ */
+async function setProperty(objectPath, propertyName, propertyValue, options = {}) {
+  const body = {
+    objectPath,
+    propertyName,
+    propertyValue,
+    access: 'WRITE_ACCESS'
+  };
+
+  const res = await request('PUT', '/remote/object/property', body, options);
+  return res.data;
+}
+
+/**
+ * Execute a console command via GameplayStatics.
+ */
+async function executeConsoleCommand(command, options = {}) {
+  return callFunction(
+    '/Script/Engine.Default__KismetSystemLibrary',
+    'ExecuteConsoleCommand',
+    {
+      WorldContextObject: '/Engine/Transient.GameEngine',
+      Command: command
+    },
+    options
+  );
+}
+
+/**
+ * Get all actors in the current level.
+ */
+async function getAllLevelActors(options = {}) {
+  return callFunction(
+    '/Script/EditorScriptingUtilities.Default__EditorLevelLibrary',
+    'GetAllLevelActors',
+    {},
+    options
+  );
+}
+
+/**
+ * Execute a Python script via the PythonScriptLibrary.
+ * This uses the Web Remote Control API to call into UE's Python subsystem.
+ */
+async function executePythonScript(script, options = {}) {
+  return callFunction(
+    '/Script/PythonScriptPlugin.Default__PythonScriptLibrary',
+    'ExecutePythonCommandEx',
+    {
+      PythonCommand: script,
+      ExecutionMode: 'EvaluateStatement',
+      FileExecutionScope: 'Public'
+    },
+    options
+  );
+}
+
+/**
+ * List available Remote Control presets.
+ */
+async function listPresets(options = {}) {
+  const res = await request('GET', '/remote/presets', null, options);
+  return res.data;
+}
+
+/**
+ * Test connection — combines health check with a simple function call.
+ */
+async function testConnection(options = {}) {
+  const health = await healthCheck(options);
+  if (!health.available) {
+    return health;
+  }
+
+  // Try to get actors as a real test
+  try {
+    await getAllLevelActors(options);
+    return {
+      available: true,
+      protocol: 'Web Remote Control (HTTP)',
+      port: options.port || DEFAULT_HTTP_PORT,
+      verified: true
+    };
+  } catch (err) {
+    return {
+      available: true,
+      protocol: 'Web Remote Control (HTTP)',
+      port: options.port || DEFAULT_HTTP_PORT,
+      verified: false,
+      warning: `Server responds but function calls may not work: ${err.message}`
+    };
+  }
+}
+
+module.exports = {
+  request,
+  healthCheck,
+  callFunction,
+  getProperty,
+  setProperty,
+  executeConsoleCommand,
+  getAllLevelActors,
+  executePythonScript,
+  listPresets,
+  testConnection,
+  DEFAULT_HTTP_PORT
+};

package/src/utils/logger.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const chalk = require('chalk');
+
+// In MCP stdio mode, all logging must go to stderr (stdout is reserved for JSON-RPC)
+let useStderr = false;
+
+function setStdioMode(enabled) {
+  useStderr = enabled;
+}
+
+function write(msg) {
+  if (useStderr) {
+    process.stderr.write(msg + '\n');
+  } else {
+    console.log(msg);
+  }
+}
+
+function info(msg) {
+  write(chalk.blue('i') + ' ' + msg);
+}
+
+function success(msg) {
+  write(chalk.green('✓') + ' ' + msg);
+}
+
+function warn(msg) {
+  write(chalk.yellow('!') + ' ' + msg);
+}
+
+function error(msg) {
+  write(chalk.red('✗') + ' ' + msg);
+}
+
+function debug(msg) {
+  if (process.env.CREATELEX_DEBUG === 'true') {
+    write(chalk.gray('[debug] ' + msg));
+  }
+}
+
+function header(msg) {
+  write('');
+  write(chalk.bold.cyan(msg));
+  write(chalk.cyan('─'.repeat(msg.length)));
+}
+
+function keyValue(key, value) {
+  write(`  ${chalk.gray(key + ':')} ${value}`);
+}
+
+function blank() {
+  write('');
+}
+
+module.exports = {
+  setStdioMode,
+  info,
+  success,
+  warn,
+  error,
+  debug,
+  header,
+  keyValue,
+  blank
+};

package/src/utils/python-manager.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+const os = require('os');
+const log = require('./logger');
+
+class PythonManager {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+    this.pythonDir = path.join(rootPath, 'python');
+    this.venvPath = path.join(this.pythonDir, 'venv');
+    this.requirementsPath = path.join(this.pythonDir, 'requirements.txt');
+    this.platform = os.platform();
+  }
+
+  getPythonCommand() {
+    const venvPython = this.platform === 'win32'
+      ? path.join(this.venvPath, 'Scripts', 'python.exe')
+      : path.join(this.venvPath, 'bin', 'python');
+
+    if (fs.existsSync(venvPython)) {
+      try {
+        execSync(`"${venvPython}" -c "import websockets, fastmcp"`, { stdio: 'pipe' });
+        log.debug(`Using venv Python: ${venvPython}`);
+        return venvPython;
+      } catch {
+        log.debug('Venv exists but packages missing');
+      }
+    }
+
+    return this.findSystemPython();
+  }
+
+  findSystemPython() {
+    const candidates = this.platform === 'win32'
+      ? ['python', 'python3', 'py -3']
+      : ['python3.12', 'python3.11', 'python3.10', 'python3', 'python'];
+
+    for (const cmd of candidates) {
+      try {
+        const output = execSync(`${cmd} --version`, { stdio: 'pipe', encoding: 'utf8' });
+        const version = output.match(/Python (\d+\.\d+)/)?.[1];
+        if (version && parseFloat(version) >= 3.10) {
+          log.debug(`Found system Python: ${cmd} (${version})`);
+          return cmd;
+        }
+      } catch {
+        // Continue
+      }
+    }
+
+    throw new Error('No compatible Python found (3.10+ required). Install Python from https://python.org');
+  }
+
+  async checkDependencies() {
+    try {
+      const pythonCmd = this.getPythonCommand();
+      execSync(`"${pythonCmd}" -c "import websockets, fastmcp, requests"`, { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async installDependencies(onProgress = null) {
+    if (!fs.existsSync(this.pythonDir)) {
+      fs.mkdirSync(this.pythonDir, { recursive: true });
+    }
+
+    const systemPython = this.findSystemPython();
+
+    if (onProgress) onProgress('Creating Python virtual environment...');
+    log.info('Creating Python virtual environment...');
+    await this.runCommand(systemPython, ['-m', 'venv', this.venvPath]);
+
+    const venvPython = this.platform === 'win32'
+      ? path.join(this.venvPath, 'Scripts', 'python.exe')
+      : path.join(this.venvPath, 'bin', 'python');
+
+    if (onProgress) onProgress('Upgrading pip...');
+    log.info('Upgrading pip...');
+    await this.runCommand(venvPython, ['-m', 'pip', 'install', '--upgrade', 'pip']);
+
+    if (onProgress) onProgress('Installing Python packages...');
+    log.info('Installing Python packages...');
+    await this.runCommand(venvPython, ['-m', 'pip', 'install', '-r', this.requirementsPath]);
+
+    log.success('Python dependencies installed');
+    return true;
+  }
+
+  runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, { stdio: 'pipe', ...options });
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => { stdout += data.toString(); });
+      child.stderr?.on('data', (data) => { stderr += data.toString(); });
+
+      child.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          reject(new Error(`Command failed (code ${code}): ${stderr || stdout}`));
+        }
+      });
+
+      child.on('error', reject);
+    });
+  }
+
+  async ensureDependencies() {
+    const hasCorrectDeps = await this.checkDependencies();
+    if (hasCorrectDeps) {
+      log.debug('Python dependencies already installed');
+      return this.getPythonCommand();
+    }
+
+    await this.installDependencies();
+    return this.getPythonCommand();
+  }
+
+  findMCPServerScript() {
+    const candidates = [
+      path.join(this.pythonDir, 'mcp_server_stdio.py'),
+      path.join(this.pythonDir, 'mcp_server_protected.py')
+    ];
+
+    for (const scriptPath of candidates) {
+      if (fs.existsSync(scriptPath)) {
+        return scriptPath;
+      }
+    }
+
+    return null;
+  }
+}
+
+module.exports = { PythonManager };