@createlex/createlexgenai 1.0.0

package/src/commands/serve.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const path = require('path');
+const net = require('net');
+const log = require('../utils/logger');
+const authManager = require('../core/auth-manager');
+const subscription = require('../core/subscription');
+const configStore = require('../core/config-store');
+const { PythonManager } = require('../utils/python-manager');
+
+async function serve(opts = {}) {
+  const isTcpMode = !!opts.port;
+
+  // In stdio mode, redirect all logging to stderr (stdout is for JSON-RPC)
+  if (!isTcpMode) {
+    log.setStdioMode(true);
+  }
+
+  if (opts.debug) {
+    process.env.CREATELEX_DEBUG = 'true';
+  }
+
+  log.info('CreatelexGenAI MCP Server starting...');
+
+  // --- Auth validation ---
+  const token = authManager.getToken();
+  if (!token) {
+    log.error('Not authenticated. Run `createlex login` first.');
+    process.exit(1);
+  }
+
+  const tokenValidation = authManager.validateTokenFormat(token);
+  if (!tokenValidation.valid) {
+    const messages = {
+      'token_expired': 'Token expired. Run `createlex login` to re-authenticate.',
+      'invalid_token_format': 'Invalid token format. Run `createlex login`.',
+      'invalid_token_structure': 'Invalid token. Run `createlex login`.'
+    };
+    log.error(messages[tokenValidation.reason] || 'Invalid token. Run `createlex login`.');
+    process.exit(1);
+  }
+
+  // --- Subscription validation ---
+  const shouldBypass = process.env.BYPASS_SUBSCRIPTION === 'true';
+
+  if (!shouldBypass) {
+    log.info('Validating subscription...');
+    const status = await subscription.getSubscriptionStatus();
+    const hasValid = subscription.hasValidSubscription(status);
+
+    if (!hasValid) {
+      if (status.seatError) {
+        log.error(`Device seat limit reached: ${status.seatError}`);
+      } else {
+        log.error('Active subscription required. Visit https://createlex.com to subscribe.');
+      }
+      process.exit(1);
+    }
+    log.success('Subscription validated');
+  } else {
+    log.warn('Subscription bypass enabled (BYPASS_SUBSCRIPTION=true)');
+  }
+
+  // --- Python setup ---
+  const rootPath = path.resolve(__dirname, '..', '..');
+  const pyManager = new PythonManager(rootPath);
+
+  let pythonCmd;
+  try {
+    pythonCmd = await pyManager.ensureDependencies();
+  } catch (err) {
+    log.error(`Python setup failed: ${err.message}`);
+    process.exit(1);
+  }
+
+  const scriptPath = pyManager.findMCPServerScript();
+  if (!scriptPath) {
+    log.error('MCP server script not found. Ensure python/mcp_server_stdio.py exists.');
+    process.exit(1);
+  }
+
+  // --- Build environment ---
+  const config = configStore.load();
+  const apiBaseUrl = config.apiBaseUrl || 'https://api.createlex.com/api';
+  const webBaseUrl = config.webBaseUrl || 'https://createlex.com';
+  const subscriptionStatus = await subscription.getSubscriptionStatus();
+
+  const envVars = {
+    ...process.env,
+    AUTH_TOKEN: token,
+    API_BASE_URL: apiBaseUrl,
+    CREATELEX_BASE_URL: webBaseUrl,
+    PYTHONIOENCODING: 'utf-8',
+    BYPASS_SUBSCRIPTION: shouldBypass ? 'true' : 'false',
+    DEV_MODE: process.env.DEV_MODE || 'false',
+    NODE_ENV: process.env.NODE_ENV || 'production',
+    BRIDGE_SUBSCRIPTION_VALIDATED: subscription.hasValidSubscription(subscriptionStatus) ? 'true' : 'false',
+    UNREAL_PORT: String(config.unrealPort || 9878),
+    UNREAL_SOCKET_PORT: String(config.unrealPort || 9878),
+    CREATELEX_USER_ID: subscriptionStatus.userId || subscriptionStatus.user_id || '',
+    CREATELEX_USER_EMAIL: subscriptionStatus.email || subscriptionStatus.userEmail || '',
+    CREATELEX_DEVICE_ID: authManager.generateDeviceId() || '',
+    CREATELEX_AUTH_TOKEN: token,
+    CREATELEX_API_URL: apiBaseUrl,
+    MCP_PLATFORM: 'cli',
+    MCP_VERSION: require('../../package.json').version
+  };
+
+  if (isTcpMode) {
+    startTcpMode(pythonCmd, scriptPath, envVars, parseInt(opts.port, 10));
+  } else {
+    startStdioMode(pythonCmd, scriptPath, envVars);
+  }
+}
+
+function startStdioMode(pythonCmd, scriptPath, envVars) {
+  log.info(`Spawning MCP server: ${scriptPath}`);
+
+  const mcpProcess = spawn(pythonCmd, [scriptPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: envVars
+  });
+
+  // Pipe stdin from parent to Python process
+  process.stdin.pipe(mcpProcess.stdin);
+
+  // Pipe stdout from Python process to parent (JSON-RPC messages)
+  mcpProcess.stdout.on('data', (data) => {
+    process.stdout.write(data);
+  });
+
+  // Pipe stderr from Python to our stderr for logging
+  mcpProcess.stderr.on('data', (data) => {
+    process.stderr.write(data);
+  });
+
+  mcpProcess.on('exit', (code) => {
+    log.info(`MCP server exited (code ${code})`);
+    process.exit(code || 0);
+  });
+
+  mcpProcess.on('error', (err) => {
+    log.error(`MCP server error: ${err.message}`);
+    process.exit(1);
+  });
+
+  // Graceful shutdown
+  const shutdown = () => {
+    mcpProcess.kill('SIGTERM');
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+function startTcpMode(pythonCmd, scriptPath, envVars, port) {
+  log.info(`Starting MCP server in TCP mode on port ${port}`);
+
+  const mcpProcess = spawn(pythonCmd, [scriptPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: envVars
+  });
+
+  let stdoutBuffer = '';
+
+  const server = net.createServer((socket) => {
+    const clientId = `${socket.remoteAddress}:${socket.remotePort}`;
+    log.info(`Client connected: ${clientId}`);
+
+    socket.on('data', (data) => {
+      if (mcpProcess.stdin && !mcpProcess.stdin.destroyed) {
+        mcpProcess.stdin.write(data);
+      }
+    });
+
+    socket.on('close', () => {
+      log.info(`Client disconnected: ${clientId}`);
+    });
+
+    socket.on('error', (err) => {
+      if (err.code !== 'ECONNRESET') {
+        log.warn(`Client error: ${err.message}`);
+      }
+    });
+
+    // Forward Python stdout to all connected clients
+    mcpProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      stdoutBuffer += output;
+
+      let lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop();
+
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            JSON.parse(line.trim());
+            socket.write(line + '\n');
+          } catch {
+            // Non-JSON output, skip
+          }
+        }
+      }
+    });
+  });
+
+  mcpProcess.stderr.on('data', (data) => {
+    process.stderr.write(data);
+  });
+
+  mcpProcess.on('exit', (code) => {
+    log.info(`MCP server exited (code ${code})`);
+    server.close();
+    process.exit(code || 0);
+  });
+
+  server.listen(port, '127.0.0.1', () => {
+    log.success(`TCP MCP server listening on 127.0.0.1:${port}`);
+  });
+
+  server.on('error', (err) => {
+    log.error(`TCP server error: ${err.message}`);
+    mcpProcess.kill('SIGTERM');
+    process.exit(1);
+  });
+
+  const shutdown = () => {
+    server.close();
+    mcpProcess.kill('SIGTERM');
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+module.exports = { serve };

package/src/commands/setup.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const log = require('../utils/logger');
+const chalk = require('chalk');
+const { IDE_CONFIGS, configureIde, getAvailableIdes } = require('../core/ide-configurator');
+
+function setup(ide, opts = {}) {
+  if (opts.all) {
+    log.header('Configuring all IDEs');
+    const ides = getAvailableIdes();
+    let configured = 0;
+
+    for (const ideInfo of ides) {
+      const result = configureIde(ideInfo.key);
+      if (result.success) {
+        if (result.manual) {
+          log.info(`${ideInfo.name}: ${result.message}`);
+        } else {
+          log.success(result.message);
+        }
+        configured++;
+      } else {
+        log.warn(`${ideInfo.name}: ${result.error}`);
+      }
+    }
+
+    log.blank();
+    log.success(`Configured ${configured}/${ides.length} IDEs`);
+    return;
+  }
+
+  if (!ide) {
+    // Show available IDEs
+    log.header('Available IDEs');
+    const ides = getAvailableIdes();
+
+    for (const ideInfo of ides) {
+      const status = ideInfo.exists ? chalk.green('available') : chalk.gray('not detected');
+      console.log(`  ${chalk.bold(ideInfo.key.padEnd(20))} ${ideInfo.name.padEnd(20)} ${status}`);
+    }
+
+    log.blank();
+    log.info('Usage: createlex setup <ide-name>');
+    log.info('       createlex setup --all');
+    log.blank();
+    log.info('Example: createlex setup claude-code');
+    return;
+  }
+
+  // Configure specific IDE
+  const result = configureIde(ide);
+  if (result.success) {
+    if (result.manual) {
+      log.header(`Setup: ${IDE_CONFIGS[ide]?.name || ide}`);
+      log.info(result.message);
+    } else {
+      log.success(result.message);
+    }
+  } else {
+    log.error(result.error);
+    process.exit(1);
+  }
+}
+
+module.exports = { setup };

package/src/commands/status.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const log = require('../utils/logger');
+const chalk = require('chalk');
+const authManager = require('../core/auth-manager');
+const subscription = require('../core/subscription');
+const configStore = require('../core/config-store');
+const { detectBackends, BACKEND } = require('../core/unreal-connection');
+
+async function status() {
+  const config = configStore.load();
+
+  log.header('CreatelexGenAI Status');
+
+  // Auth status
+  const token = authManager.getToken();
+  if (token) {
+    const validation = authManager.validateTokenFormat(token);
+    if (validation.valid) {
+      log.success('Authentication: Logged in');
+      if (validation.payload?.email) {
+        log.keyValue('  Email', validation.payload.email);
+      }
+      if (validation.payload?.exp) {
+        const expiry = new Date(validation.payload.exp * 1000);
+        log.keyValue('  Expires', expiry.toLocaleString());
+      }
+    } else {
+      log.warn(`Authentication: Token ${validation.reason}`);
+    }
+  } else {
+    log.error('Authentication: Not logged in');
+  }
+
+  log.blank();
+
+  // Subscription status
+  if (token) {
+    log.info('Checking subscription...');
+    const subStatus = await subscription.getSubscriptionStatus();
+    const hasValid = subscription.hasValidSubscription(subStatus);
+
+    if (hasValid) {
+      log.success('Subscription: Active');
+      if (subStatus.plan) {
+        log.keyValue('  Plan', subStatus.plan);
+      }
+      if (subStatus.bypass) {
+        log.warn('  (Bypass mode)');
+      }
+    } else {
+      log.error('Subscription: Inactive');
+      if (subStatus.seatError) {
+        log.keyValue('  Reason', subStatus.seatError);
+      } else if (subStatus.error) {
+        log.keyValue('  Reason', subStatus.error);
+      }
+    }
+  }
+
+  log.blank();
+
+  // Connection backends
+  log.info('Scanning Unreal Engine connections...');
+  const backends = await detectBackends({
+    pluginPort: config.unrealPort || 9878
+  });
+
+  log.blank();
+
+  const pluginStatus = backends[BACKEND.PLUGIN];
+  const webStatus = backends[BACKEND.WEB_REMOTE];
+  const remoteStatus = backends[BACKEND.REMOTE_EXEC];
+
+  // Plugin
+  if (pluginStatus.connected) {
+    log.success(`Plugin (TCP ${config.unrealPort || 9878}): ${chalk.green('Connected')}`);
+  } else {
+    log.keyValue(`Plugin (TCP ${config.unrealPort || 9878})`, chalk.gray('Not connected'));
+  }
+
+  // Web Remote Control
+  if (webStatus.connected) {
+    log.success(`Web Remote Control (HTTP ${webStatus.port || 30010}): ${chalk.green('Connected')}`);
+  } else {
+    log.keyValue(`Web Remote Control (HTTP 30010)`, chalk.gray('Not available'));
+  }
+
+  // Python Remote Execution
+  if (remoteStatus.connected) {
+    log.success(`Remote Execution (UDP 6766): ${chalk.green('Available')}`);
+    if (remoteStatus.nodes) {
+      log.keyValue('  Nodes', remoteStatus.nodes.length);
+    }
+  } else {
+    log.keyValue(`Remote Execution (UDP 6766)`, chalk.gray('Not available'));
+  }
+
+  log.blank();
+
+  // Summary
+  const connectedCount = [pluginStatus, webStatus, remoteStatus].filter(b => b.connected).length;
+  if (connectedCount > 0) {
+    log.success(`${connectedCount} backend(s) available`);
+    if (!pluginStatus.connected) {
+      log.info('Tip: Install the CreatelexGenAI plugin for full 71+ tool access.');
+    }
+  } else {
+    log.warn('No backends connected to Unreal Engine.');
+    log.info('Run `createlex connect` for setup instructions.');
+  }
+
+  log.blank();
+
+  // Config summary
+  log.keyValue('API URL', config.apiBaseUrl);
+  log.keyValue('UE Port', config.unrealPort);
+  log.keyValue('MCP Port', config.mcpPort);
+
+  const deviceInfo = authManager.getDeviceInfo();
+  log.blank();
+  log.keyValue('Device', deviceInfo.deviceName);
+  log.keyValue('Platform', deviceInfo.platform);
+}
+
+module.exports = { status };

package/src/commands/tools.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const log = require('../utils/logger');
+const chalk = require('chalk');
+
+// Tools catalog — extracted from mcp_server_stdio.py
+const TOOLS = [
+  // General
+  { name: 'how_to_use', category: 'General', description: 'Show usage instructions' },
+  { name: 'handshake_test', category: 'General', description: 'Test connection with a message echo' },
+
+  // Script Execution
+  { name: 'execute_python_script', category: 'Script', description: 'Execute a Python script in Unreal Engine' },
+  { name: 'execute_unreal_command', category: 'Script', description: 'Execute an Unreal console command' },
+
+  // Actor Management
+  { name: 'spawn_object', category: 'Actors', description: 'Spawn an actor in the scene' },
+  { name: 'get_all_scene_objects', category: 'Actors', description: 'List all actors in the current scene' },
+  { name: 'find_actors_by_name', category: 'Actors', description: 'Find actors matching a name pattern' },
+  { name: 'delete_actor', category: 'Actors', description: 'Delete an actor from the scene' },
+  { name: 'set_actor_transform', category: 'Actors', description: 'Set actor location/rotation/scale' },
+
+  // Blueprint Core
+  { name: 'create_blueprint', category: 'Blueprint', description: 'Create a new Blueprint asset' },
+  { name: 'add_component_to_blueprint', category: 'Blueprint', description: 'Add a component to a Blueprint' },
+  { name: 'add_variable_to_blueprint', category: 'Blueprint', description: 'Add a variable to a Blueprint' },
+  { name: 'add_function_to_blueprint', category: 'Blueprint', description: 'Add a function to a Blueprint' },
+  { name: 'compile_blueprint', category: 'Blueprint', description: 'Compile a Blueprint' },
+  { name: 'spawn_blueprint_actor', category: 'Blueprint', description: 'Spawn a Blueprint actor in the scene' },
+  { name: 'add_component_with_events', category: 'Blueprint', description: 'Add component with event bindings' },
+  { name: 'get_blueprint_context', category: 'Blueprint', description: 'Get Blueprint editor state and context' },
+  { name: 'edit_component_property', category: 'Blueprint', description: 'Edit a component property value' },
+
+  // Blueprint Nodes
+  { name: 'add_node_to_blueprint', category: 'Blueprint Nodes', description: 'Add a node to a Blueprint graph' },
+  { name: 'delete_node_from_blueprint', category: 'Blueprint Nodes', description: 'Delete a node from a graph' },
+  { name: 'get_all_nodes_in_graph', category: 'Blueprint Nodes', description: 'List all nodes in a graph' },
+  { name: 'connect_blueprint_nodes', category: 'Blueprint Nodes', description: 'Connect two Blueprint nodes' },
+  { name: 'connect_blueprint_nodes_bulk', category: 'Blueprint Nodes', description: 'Connect multiple node pairs at once' },
+  { name: 'get_blueprint_node_guid', category: 'Blueprint Nodes', description: 'Get the GUID of a Blueprint node' },
+  { name: 'get_node_suggestions', category: 'Blueprint Nodes', description: 'Get suggested nodes for a type' },
+  { name: 'discover_available_blueprint_nodes', category: 'Blueprint Nodes', description: 'Discover available Blueprint node types' },
+  { name: 'get_node_alternatives', category: 'Blueprint Nodes', description: 'Get alternatives for a failed node' },
+  { name: 'smart_add_node_with_discovery', category: 'Blueprint Nodes', description: 'Add a node with auto-discovery fallback' },
+  { name: 'set_node_pin_default_value', category: 'Blueprint Nodes', description: 'Set a node pin default value' },
+  { name: 'get_node_pin_info', category: 'Blueprint Nodes', description: 'Get pin information for a node' },
+
+  // Materials
+  { name: 'create_material', category: 'Materials', description: 'Create a new material with a color' },
+  { name: 'get_actor_material_info', category: 'Materials', description: 'Get material info for an actor' },
+  { name: 'get_available_materials', category: 'Materials', description: 'List available materials in a folder' },
+  { name: 'apply_material_to_actor', category: 'Materials', description: 'Apply a material to an actor' },
+  { name: 'apply_material_to_blueprint', category: 'Materials', description: 'Apply a material to a Blueprint component' },
+  { name: 'set_mesh_material_color', category: 'Materials', description: 'Set material color property' },
+
+  // Static Mesh
+  { name: 'set_static_mesh_properties', category: 'Mesh', description: 'Set static mesh component properties' },
+
+  // Physics
+  { name: 'spawn_physics_blueprint_actor', category: 'Physics', description: 'Spawn a Blueprint actor with physics' },
+  { name: 'set_physics_properties', category: 'Physics', description: 'Set physics properties on an actor' },
+
+  // UI / Widgets
+  { name: 'create_user_widget', category: 'UI', description: 'Create a new User Widget (UMG)' },
+  { name: 'add_widget_to_user_widget', category: 'UI', description: 'Add a child widget' },
+  { name: 'edit_widget_property', category: 'UI', description: 'Edit a widget property' },
+  { name: 'get_widget_hierarchy', category: 'UI', description: 'Get the widget tree hierarchy' },
+  { name: 'get_widget_properties', category: 'UI', description: 'Get widget property values' },
+  { name: 'remove_widget_from_user_widget', category: 'UI', description: 'Remove a widget from the tree' },
+  { name: 'add_widgets_bulk', category: 'UI', description: 'Add multiple widgets at once' },
+  { name: 'edit_widget_properties_bulk', category: 'UI', description: 'Edit multiple widget properties at once' },
+  { name: 'list_available_widget_types', category: 'UI', description: 'List available widget types' },
+  { name: 'bind_widget_event', category: 'UI', description: 'Bind a widget event' },
+  { name: 'validate_ui_spec', category: 'UI', description: 'Validate a UI specification' },
+  { name: 'generate_widget_blueprint_from_spec', category: 'UI', description: 'Generate widgets from a UI spec' },
+  { name: 'export_widget_to_ui_spec', category: 'UI', description: 'Export a widget tree to a UI spec' },
+
+  // UI Slicing
+  { name: 'auto_slice_ui_mockup', category: 'UI Slicing', description: 'Slice a UI mockup image into components' },
+  { name: 'apply_ui_slices_to_widget', category: 'UI Slicing', description: 'Apply sliced UI images to widgets' },
+  { name: 'auto_slice_and_apply_ui_mockup', category: 'UI Slicing', description: 'Slice and apply a UI mockup end-to-end' },
+
+  // Project / Files
+  { name: 'create_project_folder', category: 'Project', description: 'Create a folder in the content browser' },
+  { name: 'get_files_in_folder', category: 'Project', description: 'List files in a content folder' },
+  { name: 'create_game_mode', category: 'Project', description: 'Create a new Game Mode' },
+  { name: 'add_input_binding', category: 'Project', description: 'Add an input action binding' },
+
+  // Architecture / Prefabs
+  { name: 'create_town', category: 'Architecture', description: 'Generate a procedural town' },
+  { name: 'construct_house', category: 'Architecture', description: 'Construct a house structure' },
+  { name: 'construct_mansion', category: 'Architecture', description: 'Construct a mansion structure' },
+  { name: 'create_tower', category: 'Architecture', description: 'Create a tower structure' },
+  { name: 'create_arch', category: 'Architecture', description: 'Create an arch structure' },
+  { name: 'create_staircase', category: 'Architecture', description: 'Create a staircase' },
+  { name: 'create_castle_fortress', category: 'Architecture', description: 'Create a castle/fortress' },
+  { name: 'create_suspension_bridge', category: 'Architecture', description: 'Create a suspension bridge' },
+  { name: 'create_aqueduct', category: 'Architecture', description: 'Create an aqueduct' },
+  { name: 'create_maze', category: 'Architecture', description: 'Create a procedural maze' },
+  { name: 'create_pyramid', category: 'Architecture', description: 'Create a pyramid' },
+  { name: 'create_wall', category: 'Architecture', description: 'Create a wall segment' },
+];
+
+function tools(opts = {}) {
+  if (opts.json) {
+    console.log(JSON.stringify(TOOLS, null, 2));
+    return;
+  }
+
+  log.header(`CreatelexGenAI Tools (${TOOLS.length})`);
+
+  // Group by category
+  const grouped = {};
+  for (const tool of TOOLS) {
+    if (!grouped[tool.category]) {
+      grouped[tool.category] = [];
+    }
+    grouped[tool.category].push(tool);
+  }
+
+  for (const [category, categoryTools] of Object.entries(grouped)) {
+    log.blank();
+    console.log(chalk.bold.yellow(`  ${category}`));
+    for (const t of categoryTools) {
+      console.log(`    ${chalk.green(t.name.padEnd(40))} ${chalk.gray(t.description)}`);
+    }
+  }
+
+  log.blank();
+  log.info(`Use: createlex exec <tool_name> --param value`);
+}
+
+module.exports = { tools, TOOLS };