@createlex/createlexgenai 1.0.0

package/src/core/subscription.js

@@ -0,0 +1,176 @@
+'use strict';
+
+const axios = require('axios');
+const configStore = require('./config-store');
+const authManager = require('./auth-manager');
+
+// In-memory subscription cache (5-minute TTL)
+let subscriptionCache = null;
+let subscriptionCacheTimestamp = null;
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+function isCacheValid() {
+  if (!subscriptionCache || !subscriptionCacheTimestamp) return false;
+  return (Date.now() - subscriptionCacheTimestamp) < CACHE_TTL_MS;
+}
+
+function clearCache() {
+  subscriptionCache = null;
+  subscriptionCacheTimestamp = null;
+}
+
+function getApiBaseUrl() {
+  return configStore.get('apiBaseUrl') || 'https://api.createlex.com/api';
+}
+
+async function makeApiRequest(endpoint, options = {}) {
+  const { method = 'GET', data, headers = {}, timeout = 15000 } = options;
+  const baseUrl = getApiBaseUrl();
+  const normalizedBase = baseUrl.endsWith('/') ? baseUrl : `${baseUrl}/`;
+  const relativeEndpoint = endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+  const url = `${normalizedBase}${relativeEndpoint}`;
+
+  const response = await axios({
+    method,
+    url,
+    data,
+    timeout,
+    headers: {
+      'Content-Type': 'application/json',
+      ...headers
+    },
+    validateStatus: status => status >= 200 && status < 500
+  });
+
+  if (response.status >= 200 && response.status < 300) {
+    return response;
+  }
+
+  const err = new Error(`HTTP ${response.status}: ${JSON.stringify(response.data)}`);
+  err.status = response.status;
+  throw err;
+}
+
+async function getSubscriptionStatus() {
+  const token = authManager.getToken();
+  if (!token) {
+    clearCache();
+    return { hasActiveSubscription: false, error: 'No authentication token' };
+  }
+
+  const validation = authManager.validateTokenFormat(token);
+  if (!validation.valid) {
+    clearCache();
+    return { hasActiveSubscription: false, error: validation.reason };
+  }
+
+  // Return cached if valid
+  if (isCacheValid()) {
+    return subscriptionCache;
+  }
+
+  try {
+    const response = await makeApiRequest('subscription/status', {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+
+    const data = response.data || {};
+
+    const hasActiveSubscription = data.hasActiveSubscription === true ||
+                                   data.subscriptionStatus === 'active' ||
+                                   data.hasSubscription === true;
+
+    // Device seat check
+    if (hasActiveSubscription && data.userId) {
+      try {
+        const deviceInfo = authManager.getDeviceInfo();
+        const seatResponse = await makeApiRequest('device/check-seat', {
+          method: 'POST',
+          headers: { Authorization: `Bearer ${token}` },
+          data: {
+            deviceInfo,
+            subscriptionPlan: data.plan,
+            userId: data.userId
+          }
+        });
+        data.seatStatus = seatResponse.data;
+
+        if (seatResponse.data?.canUse === false) {
+          data.hasActiveSubscription = false;
+          data.seatError = seatResponse.data.error;
+        }
+      } catch (seatErr) {
+        data.seatStatus = { canUse: true, note: 'Seat check skipped: ' + seatErr.message };
+      }
+    }
+
+    data.deviceId = authManager.generateDeviceId();
+    data.deviceInfo = authManager.getDeviceInfo();
+
+    subscriptionCache = data;
+    subscriptionCacheTimestamp = Date.now();
+    return data;
+  } catch (error) {
+    // Bypass on 404/403/401 or explicit bypass
+    if (process.env.BYPASS_SUBSCRIPTION === 'true' ||
+        error.status === 404 || error.status === 403 || error.status === 401) {
+      const bypassData = {
+        hasActiveSubscription: true,
+        bypass: true,
+        error: error.message
+      };
+      subscriptionCache = bypassData;
+      subscriptionCacheTimestamp = Date.now();
+      return bypassData;
+    }
+
+    clearCache();
+    return { hasActiveSubscription: false, error: error.message };
+  }
+}
+
+function hasValidSubscription(status) {
+  if (!status) return false;
+
+  const hasSub = status.hasActiveSubscription === true ||
+                 (status.subscriptionStatus && status.subscriptionStatus.toLowerCase() === 'active') ||
+                 status.hasSubscription === true;
+
+  if (!hasSub) return false;
+
+  if (status.seatStatus && status.seatStatus.canUse === false) {
+    return false;
+  }
+
+  return true;
+}
+
+async function sendDeviceHeartbeat() {
+  const token = authManager.getToken();
+  const deviceId = authManager.generateDeviceId();
+  if (!token || !deviceId) return { success: false };
+
+  try {
+    const response = await makeApiRequest('device/heartbeat', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}` },
+      data: {
+        deviceId,
+        deviceInfo: authManager.getDeviceInfo()
+      },
+      timeout: 10000
+    });
+    return { success: true, data: response.data };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+module.exports = {
+  getSubscriptionStatus,
+  hasValidSubscription,
+  sendDeviceHeartbeat,
+  clearCache,
+  getApiBaseUrl,
+  makeApiRequest
+};

package/src/core/unreal-connection.js

@@ -0,0 +1,318 @@
+'use strict';
+
+const net = require('net');
+
+const DEFAULT_PORT = 9878;
+const CONNECT_TIMEOUT = 5000;
+const RECEIVE_TIMEOUT = 30000;
+
+// Backend identifiers
+const BACKEND = {
+  PLUGIN: 'plugin',           // CreatelexGenAI plugin TCP socket (port 9878)
+  REMOTE_EXEC: 'remote-exec', // UE Python Remote Execution (UDP 6766 + TCP)
+  WEB_REMOTE: 'web-remote'    // UE Web Remote Control HTTP API (port 30010)
+};
+
+/**
+ * Send a JSON command to Unreal Engine's socket server and return the response.
+ * This is the CreatelexGenAI plugin backend (port 9878).
+ */
+function sendCommand(command, options = {}) {
+  const port = options.port || DEFAULT_PORT;
+  const host = options.host || '127.0.0.1';
+  const timeout = options.timeout || RECEIVE_TIMEOUT;
+
+  return new Promise((resolve, reject) => {
+    const socket = new net.Socket();
+    let responseBuffer = '';
+
+    socket.setTimeout(CONNECT_TIMEOUT);
+
+    socket.connect(port, host, () => {
+      socket.setTimeout(timeout);
+      const payload = typeof command === 'string' ? command : JSON.stringify(command);
+      socket.write(payload);
+    });
+
+    socket.on('data', (data) => {
+      responseBuffer += data.toString();
+      try {
+        const parsed = JSON.parse(responseBuffer);
+        socket.destroy();
+        resolve(parsed);
+      } catch {
+        // Keep buffering
+      }
+    });
+
+    socket.on('timeout', () => {
+      socket.destroy();
+      reject(new Error(`Connection timed out (port ${port})`));
+    });
+
+    socket.on('error', (err) => {
+      socket.destroy();
+      if (err.code === 'ECONNREFUSED') {
+        reject(new Error(`Cannot connect to Unreal Engine on port ${port}. Is the editor running with the CreatelexGenAI plugin?`));
+      } else {
+        reject(new Error(`Socket error: ${err.message}`));
+      }
+    });
+
+    socket.on('close', () => {
+      if (responseBuffer.trim()) {
+        try {
+          resolve(JSON.parse(responseBuffer));
+        } catch {
+          resolve({ raw: responseBuffer.trim() });
+        }
+      }
+    });
+  });
+}
+
+/**
+ * Test if Unreal Engine is reachable on the given port (plugin backend).
+ */
+async function testConnection(port = DEFAULT_PORT) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(CONNECT_TIMEOUT);
+
+    socket.connect(port, '127.0.0.1', () => {
+      socket.destroy();
+      resolve({ connected: true, port, backend: BACKEND.PLUGIN });
+    });
+
+    socket.on('timeout', () => {
+      socket.destroy();
+      resolve({ connected: false, port, error: 'Connection timed out' });
+    });
+
+    socket.on('error', (err) => {
+      socket.destroy();
+      resolve({ connected: false, port, error: err.message });
+    });
+  });
+}
+
+/**
+ * Detect all available backends and return their status.
+ */
+async function detectBackends(options = {}) {
+  const remoteExec = require('./remote-execution');
+  const webRemote = require('./web-remote-control');
+
+  const results = {};
+
+  // Check all three in parallel
+  const [pluginResult, remoteExecResult, webRemoteResult] = await Promise.all([
+    testConnection(options.pluginPort || DEFAULT_PORT),
+    remoteExec.testConnection(),
+    webRemote.testConnection({ port: options.webRemotePort })
+  ]);
+
+  results[BACKEND.PLUGIN] = {
+    name: 'CreatelexGenAI Plugin (TCP)',
+    ...pluginResult
+  };
+
+  results[BACKEND.REMOTE_EXEC] = {
+    name: 'Python Remote Execution (UDP/TCP)',
+    connected: remoteExecResult.available,
+    ...remoteExecResult
+  };
+
+  results[BACKEND.WEB_REMOTE] = {
+    name: 'Web Remote Control (HTTP)',
+    connected: webRemoteResult.available,
+    ...webRemoteResult
+  };
+
+  return results;
+}
+
+/**
+ * Auto-select the best available backend.
+ * Priority: Plugin > Web Remote Control > Python Remote Execution
+ */
+async function autoSelectBackend(options = {}) {
+  const backends = await detectBackends(options);
+
+  if (backends[BACKEND.PLUGIN].connected) {
+    return { backend: BACKEND.PLUGIN, info: backends[BACKEND.PLUGIN] };
+  }
+  if (backends[BACKEND.WEB_REMOTE].connected) {
+    return { backend: BACKEND.WEB_REMOTE, info: backends[BACKEND.WEB_REMOTE] };
+  }
+  if (backends[BACKEND.REMOTE_EXEC].connected) {
+    return { backend: BACKEND.REMOTE_EXEC, info: backends[BACKEND.REMOTE_EXEC] };
+  }
+
+  return { backend: null, info: null, backends };
+}
+
+/**
+ * Execute a tool/command using the specified or auto-detected backend.
+ */
+async function executeWithBackend(toolName, params = {}, options = {}) {
+  const backend = options.backend || null;
+
+  if (backend === BACKEND.PLUGIN || (!backend && options.port)) {
+    // Plugin backend — send JSON-RPC to port 9878
+    const command = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: { name: toolName, arguments: params }
+    };
+    return sendCommand(command, options);
+  }
+
+  if (backend === BACKEND.WEB_REMOTE) {
+    // Web Remote Control — translate tool calls to HTTP API calls
+    const webRemote = require('./web-remote-control');
+    return executeViaWebRemote(webRemote, toolName, params, options);
+  }
+
+  if (backend === BACKEND.REMOTE_EXEC) {
+    // Python Remote Execution — generate Python code and execute
+    const remoteExec = require('./remote-execution');
+    return executeViaRemoteExec(remoteExec, toolName, params, options);
+  }
+
+  // Auto-detect
+  const selected = await autoSelectBackend(options);
+  if (!selected.backend) {
+    throw new Error('No Unreal Engine connection available. See `createlex connect` for details.');
+  }
+
+  return executeWithBackend(toolName, params, { ...options, backend: selected.backend });
+}
+
+/**
+ * Execute a tool via Web Remote Control by translating to appropriate API calls.
+ */
+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);
+
+    case 'execute_unreal_command':
+      return webRemote.executeConsoleCommand(params.command, options);
+
+    default: {
+      // For tools that don't have a direct mapping, try to execute via Python
+      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.`);
+    }
+  }
+}
+
+/**
+ * Execute a tool via Python Remote Execution by generating Python code.
+ */
+async function executeViaRemoteExec(remoteExec, toolName, params, options) {
+  switch (toolName) {
+    case 'execute_python_script':
+      return remoteExec.executeCommand(params.script, {
+        execMode: 'ExecuteStatement',
+        ...options
+      });
+
+    case 'execute_unreal_command': {
+      const pyCode = `import unreal; unreal.SystemLibrary.execute_console_command(None, "${params.command.replace(/"/g, '\\"')}")`;
+      return remoteExec.executeCommand(pyCode, {
+        execMode: 'ExecuteStatement',
+        ...options
+      });
+    }
+
+    case 'get_all_scene_objects': {
+      const pyCode = `
+import unreal, json
+actors = unreal.EditorLevelLibrary.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))
+`;
+      return remoteExec.executeCommand(pyCode, {
+        execMode: 'ExecuteStatement',
+        ...options
+      });
+    }
+
+    case 'spawn_object': {
+      const loc = params.location || '[0,0,0]';
+      const rot = params.rotation || '[0,0,0]';
+      const scale = params.scale || '[1,1,1]';
+      const pyCode = `
+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))
+if actor:
+    actor.set_actor_scale3d(unreal.Vector(*scale))
+    ${params.actor_label ? `actor.set_actor_label("${params.actor_label}")` : ''}
+    print(json.dumps({"success": True, "actor": actor.get_actor_label()}))
+else:
+    print(json.dumps({"success": False, "error": "Failed to spawn actor"}))
+`;
+      return remoteExec.executeCommand(pyCode, {
+        execMode: 'ExecuteStatement',
+        ...options
+      });
+    }
+
+    default: {
+      const script = buildPythonForTool(toolName, params);
+      if (script) {
+        return remoteExec.executeCommand(script, {
+          execMode: 'ExecuteStatement',
+          ...options
+        });
+      }
+      throw new Error(`Tool '${toolName}' is not supported via Remote Execution. Use the CreatelexGenAI plugin for full tool access.`);
+    }
+  }
+}
+
+/**
+ * Build a generic Python script to execute a tool by name.
+ * Falls back to importing from the MCP server module if available.
+ */
+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)}))
+`;
+}
+
+module.exports = {
+  BACKEND,
+  sendCommand,
+  testConnection,
+  detectBackends,
+  autoSelectBackend,
+  executeWithBackend,
+  DEFAULT_PORT
+};