@createlex/createlexgenai 1.0.0

package/src/core/auth-manager.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+const { CONFIG_DIR } = require('./config-store');
+
+const AUTH_FILE = path.join(CONFIG_DIR, 'auth.json');
+
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function loadAuth() {
+  ensureDir();
+  if (!fs.existsSync(AUTH_FILE)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(AUTH_FILE, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function saveAuth(data) {
+  ensureDir();
+  fs.writeFileSync(AUTH_FILE, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function clearAuth() {
+  if (fs.existsSync(AUTH_FILE)) {
+    fs.unlinkSync(AUTH_FILE);
+  }
+}
+
+function getToken() {
+  const auth = loadAuth();
+  return auth?.token || null;
+}
+
+function setToken(token, extra = {}) {
+  saveAuth({ token, ...extra, savedAt: new Date().toISOString() });
+}
+
+function validateTokenFormat(token) {
+  if (!token) {
+    return { valid: false, reason: 'missing_token' };
+  }
+
+  const parts = token.split('.');
+  if (parts.length !== 3) {
+    return { valid: false, reason: 'invalid_token_format' };
+  }
+
+  if (parts.some(part => !part)) {
+    return { valid: false, reason: 'invalid_token_structure' };
+  }
+
+  try {
+    const payload = JSON.parse(Buffer.from(parts[1], 'base64').toString());
+    if (payload.exp) {
+      const expiryTime = payload.exp * 1000;
+      const now = Date.now();
+      const clockSkewBuffer = 30 * 1000;
+
+      if (now >= expiryTime + clockSkewBuffer) {
+        return { valid: false, reason: 'token_expired' };
+      }
+    }
+    return { valid: true, payload };
+  } catch {
+    return { valid: false, reason: 'invalid_token_structure' };
+  }
+}
+
+function getTokenPayload() {
+  const token = getToken();
+  if (!token) return null;
+  const result = validateTokenFormat(token);
+  return result.valid ? result.payload : null;
+}
+
+function generateDeviceId() {
+  try {
+    const cpus = os.cpus();
+    const networkInterfaces = os.networkInterfaces();
+    const hostname = os.hostname();
+    const platform = os.platform();
+    const arch = os.arch();
+
+    const hardwareString = JSON.stringify({
+      hostname,
+      platform,
+      arch,
+      cpuModel: cpus[0]?.model || 'unknown',
+      cpuCount: cpus.length,
+      macAddresses: Object.values(networkInterfaces)
+        .flat()
+        .filter(iface => !iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00')
+        .map(iface => iface.mac)
+        .sort()
+    });
+
+    return crypto.createHash('sha256').update(hardwareString).digest('hex');
+  } catch {
+    return null;
+  }
+}
+
+function getDeviceInfo() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const hostname = os.hostname();
+
+  let platformName;
+  if (platform === 'win32') {
+    platformName = `Windows-${arch}`;
+  } else if (platform === 'darwin') {
+    platformName = `macOS-${arch}`;
+  } else {
+    platformName = `Linux-${arch}`;
+  }
+
+  return {
+    deviceId: generateDeviceId(),
+    deviceName: hostname,
+    platform: platformName,
+    osVersion: os.release()
+  };
+}
+
+module.exports = {
+  AUTH_FILE,
+  loadAuth,
+  saveAuth,
+  clearAuth,
+  getToken,
+  setToken,
+  validateTokenFormat,
+  getTokenPayload,
+  generateDeviceId,
+  getDeviceInfo
+};

package/src/core/config-store.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.createlex');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  unrealPort: 9878,
+  mcpPort: 38080,
+  apiBaseUrl: 'https://api.createlex.com/api',
+  webBaseUrl: 'https://createlex.com',
+  debug: false
+};
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function load() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return { ...DEFAULTS };
+  }
+  try {
+    const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+    return { ...DEFAULTS, ...JSON.parse(raw) };
+  } catch {
+    return { ...DEFAULTS };
+  }
+}
+
+function save(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+
+function get(key) {
+  const config = load();
+  return config[key];
+}
+
+function set(key, value) {
+  const config = load();
+  // Auto-parse numbers
+  if (/^\d+$/.test(value)) {
+    value = parseInt(value, 10);
+  } else if (value === 'true') {
+    value = true;
+  } else if (value === 'false') {
+    value = false;
+  }
+  config[key] = value;
+  save(config);
+  return config;
+}
+
+function reset() {
+  save({ ...DEFAULTS });
+  return DEFAULTS;
+}
+
+function list() {
+  return load();
+}
+
+module.exports = {
+  CONFIG_DIR,
+  CONFIG_FILE,
+  DEFAULTS,
+  load,
+  save,
+  get,
+  set,
+  reset,
+  list
+};

package/src/core/discovery.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const net = require('net');
+
+const UE_PORTS = [9878, 9879, 9880];
+const WEB_REMOTE_PORTS = [30010, 30011];
+const SCAN_TIMEOUT = 2000;
+
+/**
+ * Scan a single port for TCP connectivity.
+ */
+function scanPort(port) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(SCAN_TIMEOUT);
+
+    socket.connect(port, '127.0.0.1', () => {
+      socket.destroy();
+      resolve({ port, available: true });
+    });
+
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve({ port, available: false });
+    });
+
+    socket.on('error', () => {
+      socket.destroy();
+      resolve({ port, available: false });
+    });
+  });
+}
+
+/**
+ * Scan known ports for running Unreal Engine instances (plugin socket).
+ */
+async function discoverInstances() {
+  const checks = UE_PORTS.map(scanPort);
+  const results = await Promise.all(checks);
+  return results.filter(r => r.available).map(r => ({ ...r, type: 'plugin' }));
+}
+
+/**
+ * Scan Web Remote Control ports.
+ */
+async function discoverWebRemote() {
+  const checks = WEB_REMOTE_PORTS.map(scanPort);
+  const results = await Promise.all(checks);
+  return results.filter(r => r.available).map(r => ({ ...r, type: 'web-remote' }));
+}
+
+/**
+ * Discover all available connection points.
+ */
+async function discoverAll() {
+  const remoteExec = require('./remote-execution');
+
+  const [pluginInstances, webRemoteInstances, remoteExecResult] = await Promise.all([
+    discoverInstances(),
+    discoverWebRemote(),
+    remoteExec.discover(SCAN_TIMEOUT)
+  ]);
+
+  return {
+    plugin: pluginInstances,
+    webRemote: webRemoteInstances,
+    remoteExec: remoteExecResult.map(node => ({ ...node, type: 'remote-exec' }))
+  };
+}
+
+module.exports = { discoverInstances, discoverWebRemote, discoverAll, UE_PORTS, WEB_REMOTE_PORTS };

package/src/core/ide-configurator.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const log = require('../utils/logger');
+
+const HOME = os.homedir();
+const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+const LOCALAPPDATA = process.env.LOCALAPPDATA || path.join(HOME, 'AppData', 'Local');
+
+const MCP_COMMAND = 'npx';
+const MCP_ARGS = ['@createlex/createlexgenai', 'serve'];
+const SERVER_NAME = 'createlex-unreal';
+
+// IDE config paths and formats
+const IDE_CONFIGS = {
+  'claude-code': {
+    name: 'Claude Code',
+    type: 'cli',
+    setupCommand: `claude mcp add ${SERVER_NAME} -- ${MCP_COMMAND} ${MCP_ARGS.join(' ')}`
+  },
+  'cursor': {
+    name: 'Cursor',
+    type: 'json',
+    configPath: path.join(HOME, '.cursor', 'mcp.json')
+  },
+  'windsurf': {
+    name: 'Windsurf',
+    type: 'json',
+    configPath: path.join(HOME, '.codeium', 'windsurf', 'mcp_config.json')
+  },
+  'claude-desktop': {
+    name: 'Claude Desktop',
+    type: 'json',
+    configPath: path.join(APPDATA, 'Claude', 'claude_desktop_config.json')
+  },
+  'antigravity': {
+    name: 'Antigravity',
+    type: 'json',
+    configPath: path.join(HOME, '.gemini', 'antigravity', 'mcp_config.json')
+  },
+  'kiro': {
+    name: 'Kiro',
+    type: 'json',
+    configPath: path.join(HOME, '.kiro', 'settings', 'mcp.json')
+  },
+  'trae': {
+    name: 'Trae',
+    type: 'json',
+    configPath: path.join(APPDATA, 'Trae', 'User', 'mcp.json')
+  },
+  'augment': {
+    name: 'Augment',
+    type: 'json',
+    configPath: path.join(HOME, '.augment', 'mcp.json')
+  },
+  'codex': {
+    name: 'Codex',
+    type: 'toml',
+    configPath: path.join(HOME, '.codex', 'config.toml')
+  },
+  'gemini-cli': {
+    name: 'Gemini CLI',
+    type: 'json',
+    configPath: path.join(HOME, '.gemini', 'settings.json')
+  },
+  'vscode': {
+    name: 'VS Code',
+    type: 'json-settings',
+    configPath: path.join(APPDATA, 'Code', 'User', 'settings.json')
+  }
+};
+
+function getMcpServerEntry() {
+  return {
+    command: MCP_COMMAND,
+    args: MCP_ARGS
+  };
+}
+
+function configureIde(ideKey) {
+  const ide = IDE_CONFIGS[ideKey];
+  if (!ide) {
+    return { success: false, error: `Unknown IDE: ${ideKey}. Available: ${Object.keys(IDE_CONFIGS).join(', ')}` };
+  }
+
+  if (ide.type === 'cli') {
+    return { success: true, message: `Run this command:\n  ${ide.setupCommand}`, manual: true };
+  }
+
+  if (ide.type === 'toml') {
+    return configureToml(ide);
+  }
+
+  if (ide.type === 'json-settings') {
+    return configureVsCodeSettings(ide);
+  }
+
+  return configureJson(ide);
+}
+
+function configureJson(ide) {
+  const configPath = ide.configPath;
+  const dir = path.dirname(configPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    } catch {
+      config = {};
+    }
+  }
+
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+
+  config.mcpServers[SERVER_NAME] = getMcpServerEntry();
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+  return { success: true, message: `Configured ${ide.name} at ${configPath}` };
+}
+
+function configureVsCodeSettings(ide) {
+  const configPath = ide.configPath;
+
+  if (!fs.existsSync(configPath)) {
+    return { success: false, error: `VS Code settings not found at ${configPath}. Open VS Code first.` };
+  }
+
+  let settings;
+  try {
+    settings = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch {
+    return { success: false, error: 'Could not parse VS Code settings.json' };
+  }
+
+  if (!settings['mcp.servers']) {
+    settings['mcp.servers'] = {};
+  }
+
+  settings['mcp.servers'][SERVER_NAME] = getMcpServerEntry();
+
+  fs.writeFileSync(configPath, JSON.stringify(settings, null, 2), 'utf8');
+  return { success: true, message: `Configured ${ide.name} at ${configPath}` };
+}
+
+function configureToml(ide) {
+  const configPath = ide.configPath;
+  const dir = path.dirname(configPath);
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  let content = '';
+  if (fs.existsSync(configPath)) {
+    content = fs.readFileSync(configPath, 'utf8');
+  }
+
+  const tomlSection = `\n[mcp_servers.${SERVER_NAME.replace(/-/g, '_')}]\ncommand = "${MCP_COMMAND}"\nargs = [${MCP_ARGS.map(a => `"${a}"`).join(', ')}]\n`;
+
+  // Check if already configured
+  if (content.includes(`mcp_servers.${SERVER_NAME.replace(/-/g, '_')}`)) {
+    return { success: true, message: `${ide.name} already configured at ${configPath}` };
+  }
+
+  content += tomlSection;
+  fs.writeFileSync(configPath, content, 'utf8');
+  return { success: true, message: `Configured ${ide.name} at ${configPath}` };
+}
+
+function getAvailableIdes() {
+  return Object.entries(IDE_CONFIGS).map(([key, ide]) => ({
+    key,
+    name: ide.name,
+    type: ide.type,
+    configPath: ide.configPath,
+    exists: ide.configPath ? fs.existsSync(path.dirname(ide.configPath)) : true
+  }));
+}
+
+module.exports = { IDE_CONFIGS, configureIde, getAvailableIdes };

package/src/core/remote-execution.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const dgram = require('dgram');
+const net = require('net');
+const crypto = require('crypto');
+
+// UE Python Remote Execution protocol constants
+const PROTOCOL_MAGIC = 'ue_py';
+const PROTOCOL_VERSION = 1;
+
+const MULTICAST_GROUP = '239.0.0.1';
+const MULTICAST_PORT = 6766;
+const COMMAND_PORT = 6776;
+
+const DISCOVERY_TIMEOUT = 3000;
+const CONNECT_TIMEOUT = 10000;
+const COMMAND_TIMEOUT = 30000;
+
+/**
+ * Discover running Unreal Engine instances via UDP multicast ping.
+ * Returns an array of discovered nodes.
+ */
+function discover(timeout = DISCOVERY_TIMEOUT) {
+  return new Promise((resolve) => {
+    const nodes = [];
+    const nodeId = crypto.randomUUID();
+
+    const socket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+
+    const timer = setTimeout(() => {
+      socket.close();
+      resolve(nodes);
+    }, timeout);
+
+    socket.on('message', (msg) => {
+      try {
+        const data = JSON.parse(msg.toString());
+        if (data.magic === PROTOCOL_MAGIC && data.type === 'pong') {
+          // Avoid duplicates
+          if (!nodes.find(n => n.node_id === data.source)) {
+            nodes.push({
+              node_id: data.source,
+              engine_version: data.engine_version || 'unknown',
+              machine: data.machine || 'unknown',
+              user: data.user || 'unknown'
+            });
+          }
+        }
+      } catch {
+        // Ignore non-JSON or malformed messages
+      }
+    });
+
+    socket.on('error', () => {
+      clearTimeout(timer);
+      socket.close();
+      resolve(nodes);
+    });
+
+    socket.bind(0, '0.0.0.0', () => {
+      try {
+        socket.addMembership(MULTICAST_GROUP);
+      } catch {
+        // Multicast may not be available
+      }
+
+      const ping = JSON.stringify({
+        magic: PROTOCOL_MAGIC,
+        version: PROTOCOL_VERSION,
+        type: 'ping',
+        source: nodeId
+      });
+
+      socket.send(ping, 0, ping.length, MULTICAST_PORT, MULTICAST_GROUP, (err) => {
+        if (err) {
+          clearTimeout(timer);
+          socket.close();
+          resolve(nodes);
+        }
+      });
+    });
+  });
+}
+
+/**
+ * Execute a Python command on a discovered UE instance via the Remote Execution protocol.
+ *
+ * Steps:
+ * 1. Send open_connection via UDP multicast targeting the node
+ * 2. Listen on a TCP socket for the UE instance to connect back
+ * 3. Send the command as JSON over TCP
+ * 4. Receive the result
+ *
+ * @param {string} command - Python code to execute
+ * @param {object} options
+ * @param {string} options.nodeId - Target node ID from discovery (optional, broadcasts if omitted)
+ * @param {string} options.execMode - 'ExecuteStatement', 'EvaluateStatement', or 'ExecuteFile'
+ * @param {number} options.timeout - Command timeout in ms
+ */
+function executeCommand(command, options = {}) {
+  const {
+    nodeId = null,
+    execMode = 'ExecuteStatement',
+    timeout = COMMAND_TIMEOUT
+  } = options;
+
+  const clientId = crypto.randomUUID();
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error('Remote execution timed out. Ensure "Allow Python Remote Execution" is enabled in UE Project Settings > Python.'));
+    }, timeout);
+
+    // Step 1: Create TCP server to receive the connection from UE
+    const tcpServer = net.createServer((socket) => {
+      let responseBuffer = '';
+
+      socket.on('data', (data) => {
+        responseBuffer += data.toString();
+
+        // Try to parse complete JSON
+        try {
+          const result = JSON.parse(responseBuffer);
+          clearTimeout(timer);
+          tcpServer.close();
+          socket.destroy();
+
+          if (result.type === 'command_result') {
+            resolve({
+              success: result.success !== false,
+              output: result.output || '',
+              result: result.result || null,
+              outputLog: result.output_log || []
+            });
+          } else {
+            resolve({ success: true, raw: result });
+          }
+        } catch {
+          // Keep buffering
+        }
+      });
+
+      socket.on('error', (err) => {
+        clearTimeout(timer);
+        tcpServer.close();
+        reject(new Error(`TCP socket error: ${err.message}`));
+      });
+
+      // Step 3: Once UE connects, send the command
+      const commandMsg = JSON.stringify({
+        magic: PROTOCOL_MAGIC,
+        version: PROTOCOL_VERSION,
+        type: 'command',
+        source: clientId,
+        command: command,
+        unattended: false,
+        exec_mode: execMode
+      });
+
+      socket.write(commandMsg);
+    });
+
+    tcpServer.on('error', (err) => {
+      clearTimeout(timer);
+      reject(new Error(`TCP server error: ${err.message}`));
+    });
+
+    // Step 2: Start TCP server, then send open_connection via UDP
+    tcpServer.listen(0, '127.0.0.1', () => {
+      const tcpPort = tcpServer.address().port;
+
+      const udpSocket = dgram.createSocket({ type: 'udp4', reuseAddr: true });
+
+      udpSocket.bind(0, '0.0.0.0', () => {
+        try {
+          udpSocket.addMembership(MULTICAST_GROUP);
+        } catch {
+          // OK if multicast not available
+        }
+
+        const openMsg = JSON.stringify({
+          magic: PROTOCOL_MAGIC,
+          version: PROTOCOL_VERSION,
+          type: 'open_connection',
+          source: clientId,
+          dest: nodeId || '',
+          command_ip: '127.0.0.1',
+          command_port: tcpPort
+        });
+
+        udpSocket.send(openMsg, 0, openMsg.length, MULTICAST_PORT, MULTICAST_GROUP, () => {
+          udpSocket.close();
+        });
+      });
+    });
+  });
+}
+
+/**
+ * Quick test: discover + execute a simple command.
+ */
+async function testConnection() {
+  try {
+    const nodes = await discover(2000);
+    if (nodes.length === 0) {
+      return {
+        available: false,
+        error: 'No UE instances found via Remote Execution. Enable "Python Editor Script Plugin" and "Allow Python Remote Execution" in Project Settings.'
+      };
+    }
+    return {
+      available: true,
+      nodes,
+      protocol: 'Python Remote Execution (UDP/TCP)'
+    };
+  } catch (err) {
+    return { available: false, error: err.message };
+  }
+}
+
+module.exports = {
+  discover,
+  executeCommand,
+  testConnection,
+  MULTICAST_GROUP,
+  MULTICAST_PORT,
+  COMMAND_PORT
+};